public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string tokenAzure = request.DataStore.GetJson("AzureToken", "access_token");
var functionAppName = request.DataStore.GetValue("functionName");
var zipFileBinary = this.GenerateZipFile(request);
var client = new AzureHttpClient(tokenAzure);
var url = $"https://{functionAppName}.scm.azurewebsites.net/api/zipdeploy";
var result = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Post, url, zipFileBinary);
if (result.IsSuccessStatusCode)
{
return(new ActionResponse(ActionStatus.Success));
}
var response = await result.Content.ReadAsStringAsync();
return(new ActionResponse(
ActionStatus.Failure,
JsonUtility.GetJObjectFromJsonString(response),
null,
DefaultErrorCodes.DefaultErrorCode,
"Error uploading function code"));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
AzureHttpClient client = new AzureHttpClient(azureToken);
string newSqlConnectionId = GetNewSqlConnectionId();
string powerAppEnvironment = request.DataStore.GetValue("PowerAppEnvironment");
if (powerAppEnvironment == null)
{
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetEmptyJObject()));
}
string sqlConnectionString = request.DataStore.GetValueAtIndex("SqlConnectionString", "SqlServerIndex");
SqlCredentials sqlCredentials = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
string body = $"{{\"properties\":{{\"environment\":{{\"id\":\"/providers/Microsoft.PowerApps/environments/{powerAppEnvironment}\",\"name\":\"{powerAppEnvironment}\"}},\"connectionParameters\":{{\"server\":\"{sqlCredentials.Server}\",\"database\":\"{sqlCredentials.Database}\",\"username\":\"{sqlCredentials.Username}\",\"password\":\"{sqlCredentials.Password}\"}}}}}}";
string url = $"{BASE_POWER_APPS_URL}/apis/shared_sql/connections/{newSqlConnectionId}?api-version=2016-11-01&$filter=environment%20eq%20%27{powerAppEnvironment}%27";
await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Put, url, body);
//TODO: if create fails return failure
request.DataStore.AddToDataStore("PowerAppSqlConnectionId", newSqlConnectionId, DataStoreType.Private);
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetEmptyJObject()));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var tenant = request.DataStore.GetFirstValue("SPNTenantId");
var clientId = request.DataStore.GetFirstValue("SPNAppId");
var clientSecret = request.DataStore.GetFirstValue("SPNKey");
string requestUrl = $"https://manage.office.com/api/v1.0/{tenant}/activity/feed/subscriptions/start?contentType=Audit.General&PublisherIdentifier={Guid.NewGuid()}";
string resourceUri = "https://manage.office.com";
string redirectUri = request.Info.WebsiteRootUrl + Constants.WebsiteRedirectPath;
string authorityUri = $"https://login.windows.net/{tenant}/oauth2/authorize";
AuthenticationContext authContext = new AuthenticationContext(authorityUri);
ClientCredential cred = new ClientCredential(clientId, clientSecret);
AuthenticationResult token = await authContext.AcquireTokenAsync(resourceUri, cred);
AzureHttpClient client = new AzureHttpClient(token.AccessToken);
var response = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Post, requestUrl, "");
if (response.IsSuccessStatusCode)
{
return(new ActionResponse(ActionStatus.Success));
}
return(new ActionResponse(ActionStatus.Failure));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var environId = request.DataStore.GetValue("EnvironmentID").ToString();
var entityName = request.DataStore.GetValue("EntityName").ToString();
var namespaceID = environId;
var cdmEntity = System.IO.File.ReadAllText(System.IO.Path.Combine(request.ControllerModel.SiteCommonFilePath, "Service/Arm/sampleCDMEntity.json"));
//var cdmEntity = JsonUtility.GetJObjectFromJsonString(System.IO.File.ReadAllText(System.IO.Path.Combine(request.ControllerModel.SiteCommonFilePath, "Service/Arm/sampleCDMEntity.json")));
if (environId.Contains("Legacy"))
{
int indexFrom = environId.IndexOf("Legacy-") + "Legacy-".Length;
int indexTo = environId.Length;
namespaceID = environId.Substring(indexFrom, indexTo - indexFrom);
}
AzureHttpClient client = new AzureHttpClient(azureToken);
var checkEntities = await RequestUtility.CallAction(request, "Microsoft-CheckCDMEntities");
if (!checkEntities.IsSuccess)
{
return(new ActionResponse(ActionStatus.FailureExpected));
}
var response = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Put, $"https://management.azure.com/providers/Microsoft.CommonDataModel/environments/{environId}/namespaces/{namespaceID}/entities/{entityName}_?api-version=2016-11-01", cdmEntity);
var responseString = await response.Content.ReadAsStringAsync();
return(new ActionResponse(ActionStatus.Success));
}
// Exports an Activity Log for the given subscription to Event Hub
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string apiVersion = "2016-03-01";
string ehnamespace = request.DataStore.GetValue("ActivityLogNamespace");
string resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
string token = request.DataStore.GetJson("AzureToken", "access_token");
string body = $"{{\"id\":null,\"location\":null,\"name\":null,\"properties\":{{\"categories\":[\"Write\",\"Delete\",\"Action\"],\"storageAccountId\":null,\"locations\":[\"australiaeast\",\"australiasoutheast\",\"brazilsouth\",\"canadacentral\",\"canadaeast\",\"centralindia\",\"centralus\",\"eastasia\",\"eastus\",\"eastus2\",\"japaneast\",\"japanwest\",\"koreacentral\",\"koreasouth\",\"northcentralus\",\"northeurope\",\"southcentralus\",\"southindia\",\"southeastasia\",\"uksouth\",\"ukwest\",\"westcentralus\",\"westeurope\",\"westindia\",\"westus\",\"westus2\",\"global\"],\"retentionPolicy\":{{\"enabled\":false,\"days\":0}},\"serviceBusRuleId\":\"/subscriptions/{subscription}/resourceGroups/{resourceGroup}/providers/Microsoft.EventHub/namespaces/{ehnamespace}/authorizationrules/RootManageSharedAccessKey\"}},\"tags\":null}}";
string uri = $"https://management.azure.com/subscriptions/{subscription}/providers/microsoft.insights/logprofiles/default?api-version={apiVersion}";
AzureHttpClient ahc = new AzureHttpClient(token, subscription);
bool isSuccess = await ahc.IsSuccess(HttpMethod.Put, uri, body);
for (int i = 0; i < ATTEMPTS && !isSuccess; i++)
{
Thread.Sleep(WAIT);
isSuccess = await ahc.IsSuccess(HttpMethod.Put, uri, body);
}
string logProfileError = string.Empty;
if (!isSuccess)
{
logProfileError = await ahc.Test(HttpMethod.Put, uri);
}
return(isSuccess
? new ActionResponse(ActionStatus.Success)
: new ActionResponse(ActionStatus.Failure, new ActionResponseExceptionDetail("ActivityLogsErrorExportingToEventHub", logProfileError)));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var environId = request.DataStore.GetValue("EnvironmentID").ToString();
var entityName = request.DataStore.GetValue("EntityName").ToString();
var namespaceID = environId;
if (environId.Contains("Legacy"))
{
int indexFrom = environId.IndexOf("Legacy-") + "Legacy-".Length;
int indexTo = environId.Length;
namespaceID = environId.Substring(indexFrom, indexTo - indexFrom);
}
AzureHttpClient client = new AzureHttpClient(azureToken);
var response = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Get, $"https://management.azure.com/providers/Microsoft.CommonDataModel/environments/{environId}/namespaces/{namespaceID}/entities?api-version=2016-11-01&$expand=namespace", "{}");
var responseString = await response.Content.ReadAsStringAsync();
var responseParsed = JsonUtility.GetJsonObjectFromJsonString(responseString);
foreach (var obj in responseParsed["value"])
{
if (entityName == obj["name"].ToString())
{
return(new ActionResponse(ActionStatus.FailureExpected));
}
}
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string azure_access_token = request.DataStore.GetJson("AzureToken", "access_token");
string subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
string resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string jobName = request.DataStore.GetValue("SAJob");
string apiVersion = "2015-10-01";
string outputAlias = "ServiceHealthOutput";
string uri = $"https://management.azure.com/subscriptions/{subscription}/resourceGroups/{resourceGroup}/providers/Microsoft.StreamAnalytics/streamingjobs/{jobName}/outputs/{outputAlias}?api-version={apiVersion}";
string server = request.DataStore.GetValue("Server");
string database = request.DataStore.GetValue("Database");
string user = request.DataStore.GetValue("Username");
string password = request.DataStore.GetValue("Password");
string table = request.DataStore.GetValue("ServiceHealthTable");
string body = $"{{\"properties\":{{\"datasource\":{{\"type\":\"Microsoft.Sql/Server/Database\",\"properties\":{{\"server\":\"{server}\",\"database\":\"{database}\",\"table\":\"{table}\",\"user\":\"{user}\",\"password\":\"{password}\"}}}}}}}}";
AzureHttpClient ahc = new AzureHttpClient(azure_access_token, subscription);
HttpResponseMessage response = await ahc.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Put, uri, body);
if (!response.IsSuccessStatusCode)
{
for (int i = 0; i < 5; i++)
{
response = await ahc.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Put, uri, body);
if (response.IsSuccessStatusCode)
{
return(new ActionResponse(ActionStatus.Success));
}
Thread.Sleep(4000);
}
}
return(response.IsSuccessStatusCode ? new ActionResponse(ActionStatus.Success) : new ActionResponse(ActionStatus.Failure));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var environmentIds = request.DataStore.GetAllValues("EnvironmentIds");
AzureHttpClient client = new AzureHttpClient(azureToken);
foreach (var environment in environmentIds)
{
var response = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Delete, $"https://management.azure.com/providers/Microsoft.PowerApps/environments/{environment}?api-version=2016-11-01", "{}");
var responseString = await response.Content.ReadAsStringAsync();
var responseParsed = JsonUtility.GetJsonObjectFromJsonString(responseString);
//if(!response.IsSuccessStatusCode)
// {
// return new ActionResponse(ActionStatus.Failure);
// }
}
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
AzureHttpClient client = new AzureHttpClient(azureToken);
string environmentBody = "{}";
string environmentUrl = $"{BASE_POWER_APPS_URL}/environments?api-version=2016-11-01&$filter=minimumAppPermission%20eq%20%27CanEdit%27&$expand=Permissions&_poll=true";
var environmentsResponse = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Get, environmentUrl, environmentBody);
var environmentsString = await environmentsResponse.Content.ReadAsStringAsync();
var environments = JsonUtility.GetJsonObjectFromJsonString(environmentsString);
foreach (var environment in environments["value"])
{
bool isDefault = false;
bool.TryParse(environment["properties"]["isDefault"].ToString(), out isDefault);
if (isDefault && environment["properties"]["permissions"]["CreatePowerApp"] != null)
{
request.DataStore.AddToDataStore("PowerAppEnvironment", environment["name"].ToString(), DataStoreType.Private);
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetEmptyJObject()));
}
;
}
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetEmptyJObject(), "PowerAppNoEnvironment"));
//TODO: Add this error message to common
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
AzureHttpClient ahc = new AzureHttpClient(request.DataStore.GetJson("AzureToken", "access_token"));
List <PowerAppEnvironment> environments = await ahc.RequestValue <List <PowerAppEnvironment> >(HttpMethod.Get, PowerAppUtility.URL_POWERAPPS_ENVIRONMENTS);
bool foundEnvironment = false;
if (environments.IsNullOrEmpty())
{
PowerAppUtility.SkipPowerApp(request.DataStore);
foundEnvironment = true;
}
else
{
for (int i = 0; i < environments.Count && !foundEnvironment; i++)
{
PowerAppEnvironment environment = environments[i];
if (environment.Properties != null && environment.Properties.IsDefault && environment.Properties.Permissions != null && environment.Properties.Permissions.CreatePowerApp != null)
{
request.DataStore.AddToDataStore("PowerAppEnvironment", environment.Name, DataStoreType.Private);
foundEnvironment = true;
}
}
}
return(foundEnvironment
? new ActionResponse(ActionStatus.Success)
: new ActionResponse(ActionStatus.Failure, JsonUtility.GetEmptyJObject(), "PowerAppNoEnvironment"));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetJson("SelectedLocation", "Name");
var storageAccountName = request.DataStore.GetValue("StorageAccountName");
AzureHttpClient client = new AzureHttpClient(azureToken, subscription, resourceGroup);
var response = await client.ExecuteWithSubscriptionAndResourceGroupAsync(HttpMethod.Post, $"providers/Microsoft.Storage/storageAccounts/{storageAccountName}/listKeys", "2016-01-01", string.Empty);
if (response.IsSuccessStatusCode)
{
var subscriptionKeys = JsonUtility.GetJObjectFromJsonString(await response.Content.ReadAsStringAsync());
string key = subscriptionKeys["keys"][0]["value"].ToString();
string connectionString = $"DefaultEndpointsProtocol=https;AccountName={storageAccountName};AccountKey={key};EndpointSuffix=core.windows.net";
JObject newStorageAccountKey = new JObject();
newStorageAccountKey.Add("StorageAccountKey", key);
newStorageAccountKey.Add("StorageAccountConnectionString", connectionString);
request.DataStore.AddToDataStore("StorageAccountKey", key);
request.DataStore.AddToDataStore("StorageAccountConnectionString", connectionString);
return(new ActionResponse(ActionStatus.Success, newStorageAccountKey, true));
}
return(new ActionResponse(ActionStatus.Failure));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string powerAppEnvironmentId = request.DataStore.GetValue("PowerAppEnvironment");
if (powerAppEnvironmentId != null)
{
AzureHttpClient ahc = new AzureHttpClient(request.DataStore.GetJson("AzureToken", "access_token"));
string newSqlConnectionId = RandomGenerator.GetRandomHexadecimal(PowerAppUtility.SQL_CONNECTION_ID_LENGTH);
string sqlConnectionString = request.DataStore.GetValueAtIndex("SqlConnectionString", "SqlServerIndex");
SqlCredentials sqlCredentials = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
PowerAppSqlConnection powerAppSqlConnection = new PowerAppSqlConnection(sqlCredentials, powerAppEnvironmentId);
string body = JsonUtility.Serialize <PowerAppSqlConnection>(powerAppSqlConnection);
string url = string.Format(PowerAppUtility.URL_POWERAPPS_SQL_CONNECTION, newSqlConnectionId, powerAppEnvironmentId);
if (await ahc.IsSuccess(HttpMethod.Put, url, body))
{
request.DataStore.AddToDataStore("PowerAppSqlConnectionId", newSqlConnectionId, DataStoreType.Private);
}
else
{
PowerAppUtility.SkipPowerApp(request.DataStore);
}
}
return(new ActionResponse(ActionStatus.Success));
}
public override async Task<ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var cognitiveServiceKey = request.DataStore.GetAllValues("CognitiveServiceKey").LastOrDefault();
if (!string.IsNullOrEmpty(cognitiveServiceKey))
{
return new ActionResponse(ActionStatus.Success);
}
var azureToken = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
var subscription = request.DataStore.GetJson("SelectedSubscription")["SubscriptionId"].ToString();
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetJson("SelectedLocation")["Name"].ToString();
var cognitiveServiceName = request.DataStore.GetValue("CognitiveServiceName");
AzureHttpClient client = new AzureHttpClient(azureToken, subscription, resourceGroup);
var response = await client.ExecuteWithSubscriptionAndResourceGroupAsync(HttpMethod.Post, $"providers/Microsoft.CognitiveServices/accounts/{cognitiveServiceName}/listKeys", "2016-02-01-preview", string.Empty);
if (response.IsSuccessStatusCode)
{
var subscriptionKeys = JsonUtility.GetJObjectFromJsonString(await response.Content.ReadAsStringAsync());
JObject newCognitiveServiceKey = new JObject();
newCognitiveServiceKey.Add("CognitiveServiceKey", subscriptionKeys["key1"].ToString());
return new ActionResponse(ActionStatus.Success, newCognitiveServiceKey, true);
}
return new ActionResponse(ActionStatus.Failure);
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
string environmentId = request.DataStore.GetValue("PowerAppEnvironment");
string sqlConnectionId = request.DataStore.GetValue("PowerAppSqlConnectionId");
try
{
if (environmentId != null && sqlConnectionId != null)
{
ActionResponse wrangledFile = await RequestUtility.CallAction(request, "Microsoft-WranglePowerApp");
if (wrangledFile.IsSuccess && wrangledFile.Body != null)
{
string path = wrangledFile.Body.ToString();
AzureHttpClient ahc = new AzureHttpClient(azureToken);
PowerAppResourceStorage resourceStorage = await ahc.Request <PowerAppResourceStorage>(HttpMethod.Post,
string.Format(PowerAppUtility.URL_POWERAPPS_GENERATE_RESOURCE_STORAGE, JsonUtility.GetWebToken(azureToken, "oid")),
JsonUtility.Serialize <PowerAppEnvironmentWrapper>(new PowerAppEnvironmentWrapper(environmentId)));
if (!string.IsNullOrEmpty(path) && resourceStorage != null && !string.IsNullOrEmpty(resourceStorage.SharedAccessSignature))
{
string uri = resourceStorage.SharedAccessSignature.Replace("?", "/document.msapp?");
CloudBlockBlob blob = new CloudBlockBlob(new Uri(uri));
using (WebClient wc = new WebClient())
{
byte[] file = wc.DownloadData(path);
await blob.UploadFromStreamAsync(new MemoryStream(file));
PowerAppMetadata metadata = await ahc.Request <PowerAppMetadata>(HttpMethod.Post, PowerAppUtility.URL_POWERAPPS_PUBLISH_APP,
JsonUtility.Serialize <PowerAppPublish>(new PowerAppPublish(uri, $"TwitterTemplate{RandomGenerator.GetDateStamp()}", environmentId, sqlConnectionId)));
if (metadata != null)
{
if (await ahc.IsSuccess(HttpMethod.Post, string.Format(PowerAppUtility.URL_POWERAPPS_SQL_CONNECTION_UPDATE, sqlConnectionId, environmentId),
JsonUtility.Serialize <PowerAppSqlConnectionUpdate>(new PowerAppSqlConnectionUpdate(metadata.Name))))
{
if (await ahc.IsSuccess(HttpMethod.Post, string.Format(PowerAppUtility.URL_POWERAPPS_RECORD_SCOPES_CONSENT, metadata.Name), JsonUtility.Serialize <PowerAppConsents>(new PowerAppConsents(sqlConnectionId))))
{
request.DataStore.AddToDataStore("PowerAppUri", string.Format(PowerAppUtility.URL_POWERAPPS_WEB, metadata.Name));
}
}
}
}
}
}
}
}
catch
{
PowerAppUtility.SkipPowerApp(request.DataStore);
}
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string azure_access_token = request.DataStore.GetJson("AzureToken", "access_token");
string subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
string resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string apiVersion = "2015-08-01";
string ehnamespace = request.DataStore.GetValue("ActivityLogNamespace");
string uri = $"https://management.azure.com/subscriptions/{subscription}/resourceGroups/{resourceGroup}/providers/Microsoft.EventHub/namespaces/{ehnamespace}/eventhubs?api-version={apiVersion}";
string body = $"\"parameters\": {{\"namespaceName\":\"{ehnamespace}\",\"resourceGroupName\":\"{resourceGroup}\",\"api-version\":\"2015-08-01\", \"subscriptionId\": \"{subscription}\"}}";
AzureHttpClient ahc = new AzureHttpClient(azure_access_token, subscription);
bool areHubsPresent = false;
for (int i = 0; i < RETRIES && !areHubsPresent; i++)
{
if (!areHubsPresent)
{
Thread.Sleep(SLEEP);
}
List <EventHub> hubs = await ahc.RequestValue <List <EventHub> >(HttpMethod.Get, uri, body);
if (!hubs.IsNullOrEmpty())
{
foreach (EventHub hub in hubs)
{
if (hub.Name.EqualsIgnoreCase(INSIGHTS))
{
areHubsPresent = true;
break;
}
}
}
}
return(areHubsPresent ? new ActionResponse(ActionStatus.Success) : new ActionResponse(ActionStatus.Failure));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var subscriptionKey = request.DataStore.GetValue("CognitiveServiceKey");
AzureHttpClient client = new AzureHttpClient(new Dictionary <string, string>()
{
{ "Ocp-Apim-Subscription-Key", subscriptionKey }
});
HttpResponseDetails response = await client.GetJsonDetails(HttpMethod.Post, $"https://westus.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment");
if (response.Code == HttpStatusCode.BadRequest)
{
var obj = JsonUtility.GetJObjectFromJsonString(response.Json);
return(new ActionResponse(ActionStatus.Success));
}
if (response.Code == HttpStatusCode.Unauthorized)
{
var obj = JsonUtility.GetJObjectFromJsonString(response.Json);
return(new ActionResponse(ActionStatus.FailureExpected));
}
return(new ActionResponse(ActionStatus.Failure));
}
/// <summary>
/// Creates a new project
/// </summary>
/// <param name="name">Name of the project</param>
/// <param name="visibility">Visibility of the project</param>
/// <returns>Response wrapped in JSON object</returns>
public async Task <JObject> Create(string name, string visibility)
{
string response;
var dto = new CreateProjectDto
{
Name = name,
Description = "Generated project by DevOpsApiClient",
Visibility = visibility,
Capabilities = new Capabilities
{
VersionControl = new VersionControl
{
SourceControlType = "Git"
},
ProcessTemplate = new ProcessTemplate
{
TemplateTypeId = "adcc42ab-9882-485e-a3ed-7678f01f66bc"
}
},
};
using (var client = new AzureHttpClient(Credentials.AccessToken))
{
using (var responseMessage =
await client.PostAsync(GenerateUrl("/projects", false), HttpConvert.ToRequestBody(dto)))
{
response = await responseMessage.Content.ReadAsStringAsync();
}
}
return(JObject.Parse(response));
}
static async Task Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", false, true);
var configuration = builder.Build();
var serverUrlAddresses = JsonConvert.DeserializeObject <IEnumerable <ServerModel> >(configuration["ServersJson"]);
IAzureHttpClient azureHttpClient = new AzureHttpClient();
IListenerService listenerService = new ListenerService(azureHttpClient, serverUrlAddresses);
Console.CancelKeyPress += (sender, eventArgs) => isStop = true;
while (!isStop)
{
Console.Clear();
foreach (var server in await listenerService.GetInstanceIdServers())
{
Console.WriteLine($"{server.Name} - {server.Url}\tInstanceId: {server.InstanceId} [{server.Ping} ms.]");
}
Console.WriteLine("Press Ctrl+C or Ctrl+Break for exit");
Thread.Sleep(1000);
}
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var token = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var sitename = request.DataStore.GetJson("SiteName");
dynamic obj = new ExpandoObject();
obj.hostName = ".azurewebsites.net";
obj.siteName = sitename;
obj.subscriptionId = subscription;
AzureHttpClient client = new AzureHttpClient(token, subscription);
var statusResponse = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Post, @"https://web1.appsvcux.ext.azure.com/websites/api/Websites/ValidateSiteName",
JsonUtility.GetJsonStringFromObject(obj));
var response = await statusResponse.Content.ReadAsStringAsync();
if (!statusResponse.IsSuccessStatusCode)
{
return(new ActionResponse(ActionStatus.FailureExpected, JsonUtility.GetJsonObjectFromJsonString(response), null, AzureErrorCodes.AzureWebsiteNameTaken));
}
return(new ActionResponse(ActionStatus.Success, response));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
string server = request.DataStore.GetJson("SqlCredentials", "Server");
AzureHttpClient httpClient = new AzureHttpClient(azureToken, subscription);
dynamic payload = new ExpandoObject();
payload.name = server.Replace(".database.windows.net", "");
payload.type = "Microsoft.Sql/servers";
HttpResponseMessage response = await httpClient.ExecuteWithSubscriptionAsync(HttpMethod.Post, $"/providers/Microsoft.Sql/checkNameAvailability", "2014-04-01-preview",
JsonUtility.GetJsonStringFromObject(payload));
string content = await response.Content.ReadAsStringAsync();
var json = JsonUtility.GetJObjectFromJsonString(content);
bool isAvailable = json["available"].ToString().EqualsIgnoreCase("True");
string reason = json["reason"].ToString();
string message = json["message"].ToString();
if (isAvailable)
{
return(new ActionResponse(ActionStatus.Success, ""));
}
else
{
// Handle basic errorcases here
return(new ActionResponse(ActionStatus.FailureExpected, json, null, SqlErrorCodes.DatabaseAlreadyExists));
}
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
JObject graphToken = AzureTokenUtility.GetTokenForResource(request, azureToken, "https://graph.windows.net");
var tenantId = AzureUtility.GetTenantFromToken(request.DataStore.GetJson("AzureToken"));
// Generate new key for ClientSecret
string key = GetNewKey();
string graphUriBase = "https://graph.windows.net/{0}/applications";
string graphApi = string.Format(graphUriBase, tenantId);
AzureHttpClient client = new AzureHttpClient(graphToken["access_token"].ToString(), subscription);
dynamic payload = new ExpandoObject();
payload.displayName = "solutiontemplate";
payload.availableToOtherTenants = false;
payload.homepage = "www.test.com";
payload.identifierUris = new string[1];
payload.identifierUris[0] = "https://test.com/" + RandomGenerator.GetRandomLowerCaseCharacters(10);
payload.passwordCredentials = new ExpandoObject[1];
payload.passwordCredentials[0] = new ExpandoObject();
payload.passwordCredentials[0].startDate = DateTime.UtcNow.ToString("o");
payload.passwordCredentials[0].endDate = DateTime.UtcNow.AddYears(3).ToString("o");
payload.passwordCredentials[0].keyId = Guid.NewGuid();
payload.passwordCredentials[0].value = key;
string body = JsonUtility.GetJsonStringFromObject(payload);
var response = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Post, graphApi + "?api-version=1.6", body);
string responseBody = await response.Content.ReadAsStringAsync();
JObject responseBodyObj = JsonUtility.GetJObjectFromJsonString(responseBody);
if (response.IsSuccessStatusCode)
{
string appId = responseBodyObj["appId"].ToString();
string obbId = responseBodyObj["objectId"].ToString();
responseBodyObj.Add("SPNAppId", appId);
responseBodyObj.Add("SPNKey", key);
responseBodyObj.Add("SPNUser", "app:" + appId + "@" + tenantId);
responseBodyObj.Add("SPNTenantId", tenantId);
// Delete the SPN if required
//string graphUriBaseWithApplication = "https://graph.windows.net/{0}/applications/{1}";
//string graphApiWithApp = string.Format(graphUriBaseWithApplication, tenantId, obbId);
//response = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Delete, graphApiWithApp + "?api-version=1.6", body);
return(new ActionResponse(ActionStatus.Success, responseBodyObj, true));
}
return(new ActionResponse(ActionStatus.Failure, responseBody, null, null, "Unable to create a Service Principal"));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
AzureHttpClient client = new AzureHttpClient(request.DataStore.GetJson("PBIToken", "access_token"));
PBIWorkspaces pbiWorkspaces = await client.Request <PBIWorkspaces>(HttpMethod.Get, request.DataStore.GetValue("PBIClusterUri") + PBI_ENDPOINT_GROUPS);
return(new ActionResponse(ActionStatus.Success, JsonUtility.Serialize <List <PBIWorkspace> >(pbiWorkspaces.Workspaces)));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
AzureHttpClient client = new AzureHttpClient(request.DataStore.GetJson("PBIToken", "access_token"));
PBIClusterUri pbiClusterUri = await client.Request <PBIClusterUri>(HttpMethod.Put, PBI_CLUSTER_URIS_URL);
request.DataStore.AddToDataStore("PBIClusterUri", pbiClusterUri.FixedClusterUri);
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string token = request.DataStore.GetJson("AzureToken", "access_token");
string subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
string uri = "https://api.powerbi.com/v1.0/myorg/groups";
AzureHttpClient ahc = new AzureHttpClient(token, subscription);
HttpResponseMessage response = await ahc.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Get, uri, "{}");
return(response.IsSuccessStatusCode ? new ActionResponse(ActionStatus.Success) : new ActionResponse(ActionStatus.Failure));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
AzureHttpClient client = new AzureHttpClient(request.DataStore.GetJson("PBIToken", "access_token"));
string pbiClusterUri = request.DataStore.GetValue("PBIClusterUri");
PBIWorkspaces pbiWorkspaces = JsonUtility.Deserialize <PBIWorkspaces>(await client.Request(HttpMethod.Get, pbiClusterUri + PBI_ENDPOINT_GROUPS));
pbiWorkspaces.Workspaces.Insert(0, new PBIWorkspace(PBI_DEFAULT_WORKSPACE));
return(new ActionResponse(ActionStatus.Success, JsonUtility.Serialize <List <PBIWorkspace> >(pbiWorkspaces.Workspaces)));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetJson("SelectedLocation", "Name");
var sitename = request.DataStore.GetValue("FunctionName");
List <KeyValuePair <string, string> > appSettings = new List <KeyValuePair <string, string> >();
if (request.DataStore.GetJson("AppSettingKeys") != null)
{
foreach (var item in request.DataStore.GetJson("AppSettingKeys"))
{
string key = item.Path.Split('.').Last();
string value = (string)item;
appSettings.Add(new KeyValuePair <string, string>(key, value));
}
}
AzureHttpClient client = new AzureHttpClient(azureToken, subscription, resourceGroup);
dynamic obj = new ExpandoObject();
obj.subscriptionId = subscription;
obj.siteId = new ExpandoObject();
obj.siteId.Name = sitename;
obj.siteId.ResourceGroup = resourceGroup;
obj.connectionStrings = new ExpandoObject[appSettings.Count];
obj.location = location;
if (appSettings.Count != 0)
{
for (int i = 0; i < appSettings.Count; i++)
{
obj.connectionStrings[i] = new ExpandoObject();
obj.connectionStrings[i].ConnectionString = appSettings[i].Value;
obj.connectionStrings[i].Name = appSettings[i].Key;
obj.connectionStrings[i].Type = 2;
}
}
var appSettingCreated = await client.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Post, @"https://web1.appsvcux.ext.azure.com/websites/api/Websites/UpdateConfigConnectionStrings",
JsonUtility.GetJsonStringFromObject(obj));
var response = await appSettingCreated.Content.ReadAsStringAsync();
if (!appSettingCreated.IsSuccessStatusCode)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromJsonString(response),
null, DefaultErrorCodes.DefaultErrorCode, "Error creating appsetting"));
}
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var idSubscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
AzureHttpClient client = new AzureHttpClient(azureToken, idSubscription);
var response = await client.ExecuteWithSubscriptionAsync(HttpMethod.Get, $"providers/Microsoft.Storage/storageAccounts", "2017-06-01", string.Empty);
if (response.IsSuccessStatusCode)
{
var storageAccounts = JsonUtility.GetJObjectFromJsonString(await response.Content.ReadAsStringAsync());
JArray array = new JArray();
var tasks = storageAccounts["value"].Select(async item =>
{
var storageAccountId = item["id"].ToString();
var storageAccountName = item["name"].ToString();
var connectionString = await this.GetStorageAccountConnectionStringAsync(azureToken, idSubscription, storageAccountName, storageAccountId);
var containers = await this.GetContainersAsync(connectionString);
return(new JObject
{
{ "StorageAccountId", storageAccountId },
{ "StorageAccountName", storageAccountName },
{ "StorageAccountConnectionString", connectionString },
{ "Containers", containers }
});
}).ToArray();
await Task.WhenAll(tasks);
foreach (var task in tasks)
{
array.Add(task.Result);
}
request.Logger.LogEvent("GetAzureStorages-result", new Dictionary <string, string>()
{
{ "Storages", array.ToString() }
});
request.DataStore.AddToDataStore("StorageAccounts", array);
return(new ActionResponse(ActionStatus.Success, array, true));
}
var error = await response.Content.ReadAsStringAsync();
return(new ActionResponse(ActionStatus.Failure, error, null, DefaultErrorCodes.DefaultErrorCode, "GetAzureStorages"));
}
// Starts the specified Stream Analytics job
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string token = request.DataStore.GetJson("AzureToken", "access_token");
string subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
string resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string apiVersion = "2015-10-01";
string jobName = request.DataStore.GetValue("SAJob");
string uri = $"https://management.azure.com/subscriptions/{subscription}/resourceGroups/{resourceGroup}/providers/Microsoft.StreamAnalytics/streamingjobs/{jobName}/start?api-version={apiVersion}";
AzureHttpClient ahc = new AzureHttpClient(token, subscription);
HttpResponseMessage response = await ahc.ExecuteGenericRequestWithHeaderAsync(HttpMethod.Post, uri, "{}");
return(response.IsSuccessStatusCode ? new ActionResponse(ActionStatus.Success) : new ActionResponse(ActionStatus.Failure));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
AzureHttpClient ahc = new AzureHttpClient(request.DataStore.GetJson("PBIToken", "access_token"));
string pbiClusterUri = request.DataStore.GetValue("PBIClusterUri");
string pbiWorkspaceId = request.DataStore.GetValue("PBIWorkspaceId");
string pbixLocation = request.DataStore.GetValue("PBIXLocation");
pbiWorkspaceId = string.IsNullOrEmpty(pbiWorkspaceId) ? string.Empty : "groups/" + pbiWorkspaceId + "/";
byte[] file = null;
using (WebClient wc = new WebClient())
{
file = wc.DownloadData(pbixLocation);
}
string filename = request.Info.AppName + RandomGenerator.GetDateStamp() + ".pbix";
PBIImport pbiImport = JsonUtility.Deserialize <PBIImport>(await ahc.Request(pbiClusterUri + string.Format(PBI_IMPORT_URI, pbiWorkspaceId, filename), file, filename));
PBIImportStatus pbiImportStatus = null;
int attempts = 0;
bool isImportInProgress = true;
while (isImportInProgress && attempts < MAXIMUM_IMPORT_STATUS_ATTEMPTS)
{
pbiImportStatus = await ahc.Request <PBIImportStatus>(HttpMethod.Get, pbiClusterUri + string.Format(PBI_IMPORT_STATUS_URI, pbiWorkspaceId, pbiImport.Id));
switch (pbiImportStatus.ImportState)
{
case "Publishing":
Thread.Sleep(new TimeSpan(0, 0, WAIT_IMPORT_STATUS));
break;
case "Succeeded":
isImportInProgress = false;
break;
default:
isImportInProgress = false;
break;
}
attempts++;
}
string reportUrl = pbiImportStatus == null || pbiImportStatus.Reports == null || pbiImportStatus.Reports.Count == 0 ? string.Empty : pbiImportStatus.Reports[0].WebUrl;
string pbixDatasetId = pbiImportStatus == null || pbiImportStatus.Datasets == null || pbiImportStatus.Datasets.Count == 0 ? string.Empty : pbiImportStatus.Datasets[0].Id;
request.DataStore.AddToDataStore("PBIXDatasetId", pbixDatasetId, DataStoreType.Public);
return(new ActionResponse(ActionStatus.Success, reportUrl));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string keyNumber = request.DataStore.GetValue("KeyNumber") ?? "0";
int keyNumberParsed = int.Parse(keyNumber);
var cognitiveServiceKeys = request.DataStore.GetAllValues("CognitiveServiceKey");
if (cognitiveServiceKeys.Count - 1 >= keyNumberParsed)
{
string key = cognitiveServiceKeys[keyNumberParsed];
if (!string.IsNullOrEmpty(key))
{
return(new ActionResponse(ActionStatus.Success));
}
}
var azureToken = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
var subscription = request.DataStore.GetJson("SelectedSubscription")["SubscriptionId"].ToString();
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetJson("SelectedLocation")["Name"].ToString();
var cognitiveServiceName = request.DataStore.GetValue("CognitiveServiceName");
var cognitiveServiceType = request.DataStore.GetValue("CognitiveServiceType");
AzureHttpClient client = new AzureHttpClient(azureToken, subscription, resourceGroup);
var response = await client.ExecuteWithSubscriptionAndResourceGroupAsync(HttpMethod.Post, $"providers/Microsoft.CognitiveServices/accounts/{cognitiveServiceName}/listKeys", "2016-02-01-preview", string.Empty);
if (response.IsSuccessStatusCode)
{
var subscriptionKeys = JsonUtility.GetJObjectFromJsonString(await response.Content.ReadAsStringAsync());
JObject newCognitiveServiceKey = new JObject();
newCognitiveServiceKey.Add("CognitiveServiceKey", subscriptionKeys["key1"].ToString());
string cognitiveKey = subscriptionKeys["key1"].ToString();
var itemsInDataStore = request.DataStore.GetAllDataStoreItems("CognitiveServiceKey");
if (itemsInDataStore.Count - 1 >= keyNumberParsed)
{
request.DataStore.UpdateValue(itemsInDataStore[keyNumberParsed].DataStoreType, itemsInDataStore[keyNumberParsed].Route, itemsInDataStore[keyNumberParsed].Key, cognitiveKey);
}
else
{
request.DataStore.AddToDataStore("CognitiveServiceKey", cognitiveKey);
}
return(new ActionResponse(ActionStatus.Success, newCognitiveServiceKey, true));
}
return(new ActionResponse(ActionStatus.Failure));
}
