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 static List <string> GetListOfDatabases(SqlCredentials credentials, bool showOnlyWriteEnabled = false, bool showSystemDB = false)
{
var connectionString = GetConnectionString(credentials);
var result = GetListOfDatabases(connectionString);
if (showOnlyWriteEnabled)
{
var databasesToReturn = new List <string>();
foreach (var database in result)
{
credentials.Database = database;
connectionString = GetConnectionString(credentials);
if (IsDatabaseWriteEnabled(connectionString))
{
databasesToReturn.Add(database);
}
}
result = databasesToReturn;
}
if (!showSystemDB)
{
result.RemoveAll(p =>
string.Equals("master", p, StringComparison.OrdinalIgnoreCase) ||
string.Equals("tempdb", p, StringComparison.OrdinalIgnoreCase) ||
string.Equals("msdb", p, StringComparison.OrdinalIgnoreCase) ||
string.Equals("model", p, StringComparison.OrdinalIgnoreCase));
}
return(result);
}
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 static DataTable InvokeSqlCommandWithData(SqlCredentials credentials, string script, Dictionary <string, string> args)
{
var connectionString = GetConnectionString(credentials);
script = ReplaceScriptWithArgs(script, args);
return(RunCommand(connectionString, script, SqlCommandType.ExecuteWithData));
}
public static string GetConnectionString(SqlCredentials credentials)
{
SqlConnectionStringBuilder conn = new SqlConnectionStringBuilder
{
DataSource = credentials.Server,
ConnectTimeout = 15
};
// Add encryption if we're targeting an Azure server
if (credentials.Server.IndexOf(".database.windows.net", StringComparison.OrdinalIgnoreCase) > 0)
{
conn.Encrypt = true;
conn.TrustServerCertificate = false;
}
conn.InitialCatalog = credentials.Database ?? (credentials.AlternativeDatabaseToConnect ?? "master");
if (credentials.Authentication == SqlAuthentication.SQL)
{
conn.IntegratedSecurity = false;
conn.UserID = credentials.Username;
conn.Password = credentials.Password;
}
else
{
conn.IntegratedSecurity = true;
}
return(conn.ConnectionString);
}
public PowerAppSqlConnectionPropertiesConnectionParameters(SqlCredentials sqlCredentials)
{
Database = sqlCredentials.Database;
Password = sqlCredentials.Password;
Server = sqlCredentials.Server;
Username = sqlCredentials.Username;
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string connectionString = request.DataStore.GetValueAtIndex("SqlConnectionString", "SqlServerIndex");
string[] originalFiles = request.DataStore.GetValue("FileName").Split('|');
string[] tempFolders = new string[originalFiles.Length];
for (int i = 0; i < originalFiles.Length; i++)
{
string templateFullPath = request.Info.App.AppFilePath + $"/service/PowerBI/{originalFiles[i]}";
tempFolders[i] = Path.GetRandomFileName();
Directory.CreateDirectory(request.Info.App.AppFilePath + $"/Temp/{tempFolders[i]}");
SqlCredentials creds = SqlUtility.GetSqlCredentialsFromConnectionString(connectionString);
using (PBIXUtils wrangler = new PBIXUtils(templateFullPath, request.Info.App.AppFilePath + $"/Temp/{tempFolders[i]}/{originalFiles[i]}"))
{
wrangler.ReplaceKnownVariableinMashup("STSqlServer", creds.Server);
wrangler.ReplaceKnownVariableinMashup("STSqlDatabase", creds.Database);
}
}
string serverPath = string.Empty;
if (originalFiles.Length == 1)
{
serverPath = request.Info.ServiceRootUrl + request.Info.ServiceRelativePath + request.Info.App.AppRelativeFilePath + $"/Temp/{tempFolders[0]}/{originalFiles[0]}";
}
else
{
string randomZipFolder = Path.GetRandomFileName();
DirectoryInfo d = Directory.CreateDirectory(Path.Combine(request.Info.App.AppFilePath, "Temp", randomZipFolder));
serverPath = Path.Combine(d.FullName, "SolutionTemplate.zip");
using (FileStream zipFile = AVAwareOpen(serverPath, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read))
{
using (ZipArchive z = new ZipArchive(zipFile, ZipArchiveMode.Update))
{
for (int i = 0; i < originalFiles.Length; i++)
{
ZipArchiveEntry entry = z.CreateEntry(originalFiles[i], CompressionLevel.Optimal);
using (Stream w = entry.Open())
{
string fileToZip = Path.Combine(request.Info.App.AppFilePath, "Temp", tempFolders[i], originalFiles[i]);
using (FileStream source = AVAwareOpen(fileToZip, FileMode.Open, FileAccess.Read, FileShare.Read))
{
source.CopyTo(w);
w.Flush();
}
}
}
}
}
// reconstruct a web server path
serverPath = request.Info.ServiceRootUrl + request.Info.ServiceRelativePath + request.Info.App.AppRelativeFilePath + $"/Temp/{randomZipFolder}/SolutionTemplate.zip";;
}
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetJObjectFromStringValue(serverPath)));
}
private static string ReplaceSqlPasswords(SqlCredentials sqlCredentials, string json)
{
JObject obj = JsonUtility.GetJsonObjectFromJsonString(json);
var nodes = obj["properties"]["package"]["nodes"];
foreach (var node in nodes.Children())
{
var nodeConverted = node.Children().First();
if (nodeConverted.SelectToken("parameters") != null)
{
if (nodeConverted["parameters"]["Database Server Name"] != null)
{
nodeConverted["parameters"]["Database Server Name"] = sqlCredentials.Server;
}
if (nodeConverted["parameters"]["Database Name"] != null)
{
nodeConverted["parameters"]["Database Name"] = sqlCredentials.Database;
}
if (nodeConverted["parameters"]["Server User Account Name"] != null)
{
nodeConverted["parameters"]["Server User Account Name"] = sqlCredentials.Username;
}
if (nodeConverted["parameters"]["Server User Account Password"] != null)
{
nodeConverted["parameters"]["Server User Account Password"] = sqlCredentials.Password;
}
}
}
if (obj["properties"].SelectToken("parameters") != null)
{
if (obj["properties"]["parameters"]["database server name"] != null)
{
obj["properties"]["parameters"]["database server name"] = sqlCredentials.Server;
}
if (obj["properties"]["parameters"]["database name"] != null)
{
obj["properties"]["parameters"]["database name"] = sqlCredentials.Database;
}
if (obj["properties"]["parameters"]["user name"] != null)
{
obj["properties"]["parameters"]["user name"] = sqlCredentials.Username;
}
if (obj["properties"]["parameters"]["Server User Account Password"] != null)
{
obj["properties"]["parameters"]["Server User Account Password"] = sqlCredentials.Password;
}
}
return(obj.ToString());
}
public static SqlCredentials GetSQLCredentials()
{
SqlCredentials credentials = new SqlCredentials();
credentials.DataSource = ConfigurationManager.AppSettings["DataSource"];
credentials.UserId = ConfigurationManager.AppSettings["UserId"];
credentials.Password = ConfigurationManager.AppSettings["Password"];
credentials.InitialCatalog = ConfigurationManager.AppSettings["InitialCatalog"];
return credentials;
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string rowBatchSize = request.DataStore.GetValue("RowBatchSize");
string sapClient = request.DataStore.GetValue("SapClient");
string sapHost = request.DataStore.GetValue("SapHost");
string sapLanguage = request.DataStore.GetValue("SapLanguage");
string sapRouterString = request.DataStore.GetValue("SapRouterString");
string sapSystemId = request.DataStore.GetValue("SapSystemId");
string sapSystemNumber = request.DataStore.GetValue("SapSystemNumber");
var sqlConnectionStrings = request.DataStore.GetAllValues("SqlConnectionString");
string sqlConnectionString = sqlConnectionStrings != null ? sqlConnectionStrings[0] : string.Empty;
if (!string.IsNullOrEmpty(sqlConnectionString))
{
SqlCredentials sqlCredentials = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
sqlCredentials.Username = string.Empty;
sqlCredentials.Password = string.Empty;
sqlConnectionString = SqlUtility.GetConnectionString(sqlCredentials);
}
string jsonDestination = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), JSON_PATH);
(new FileInfo(jsonDestination)).Directory.Create();
JObject config = new JObject(
new JProperty("RowBatchSize", rowBatchSize),
new JProperty("SapClient", sapClient),
new JProperty("SapHost", sapHost),
new JProperty("SapLanguage", sapLanguage),
new JProperty("SapRouterString", sapRouterString),
new JProperty("SapSystemId", sapSystemId),
new JProperty("SapSystemNumber", sapSystemNumber),
new JProperty("SqlConnectionString", sqlConnectionString)
);
using (StreamWriter file = File.CreateText(jsonDestination))
{
using (JsonTextWriter writer = new JsonTextWriter(file))
{
config.WriteTo(writer);
}
}
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetEmptyJObject()));
}
public static void RunSqlCommandWithoutTransaction(SqlCredentials creds, string commandText)
{
var connString = SqlUtility.GetConnectionString(creds).Replace("Connect Timeout=15", "Connect Timeout=60");
using (var cn = new SqlConnection(connString))
{
cn.Open();
using (var command = cn.CreateCommand())
{
command.CommandTimeout = 60;
command.CommandText = commandText;
command.Transaction = null;
command.ExecuteNonQuery();
}
cn.Close();
}
}
public static void RemoveTempDB()
{
SqlCredentials creds = new SqlCredentials()
{
Server = Credential.Instance.Sql.Server,
Username = Credential.Instance.Sql.Username,
Password = Credential.Instance.Sql.Password,
Authentication = SqlAuthentication.SQL,
Database = "master"
};
string command = $"SET IMPLICIT_TRANSACTIONS OFF; " +
$"IF EXISTS (SELECT * FROM sys.databases WHERE name='{CurrentDatabase}') " +
$"DROP DATABASE [{CurrentDatabase}];";
RunSqlCommandWithoutTransaction(creds, command);
}
public void SetConfigValuesInSql_Success()
{
var dataStore = TestHarness.GetCommonDataStoreWithSql().Result;
dataStore.AddToDataStore("SqlServerIndex", 0, DataStoreType.Any);
dataStore.AddToDataStore("Customize", "SqlGroup", "SolutionTemplate", DataStoreType.Public);
dataStore.AddToDataStore("Customize", "SqlSubGroup", "System Center", DataStoreType.Public);
dataStore.AddToDataStore("Customize", "SqlEntryName", "endpointcompliancetarget", DataStoreType.Public);
dataStore.AddToDataStore("Customize", "SqlEntryValue", "0.99", DataStoreType.Public);
dataStore.AddToDataStore("Customize1", "SqlGroup", "SolutionTemplate", DataStoreType.Public);
dataStore.AddToDataStore("Customize1", "SqlSubGroup", "System Center", DataStoreType.Public);
dataStore.AddToDataStore("Customize1", "SqlEntryName", "healthevaluationtarget", DataStoreType.Public);
dataStore.AddToDataStore("Customize1", "SqlEntryValue", "0.99", DataStoreType.Public);
dataStore.AddToDataStore("Customize3", "SqlGroup", "SolutionTemplate", DataStoreType.Public);
dataStore.AddToDataStore("Customize3", "SqlSubGroup", "System Center", DataStoreType.Public);
dataStore.AddToDataStore("Customize3", "SqlEntryName", "healthevaluationtarget", DataStoreType.Public);
dataStore.AddToDataStore("Customize3", "SqlEntryValue", "120", DataStoreType.Public);
SqlCredentials creds = new SqlCredentials()
{
Server = Credential.Instance.Sql.Server,
Username = Credential.Instance.Sql.Username,
Password = Credential.Instance.Sql.Password,
Authentication = SqlAuthentication.SQL,
Database = TestHarness.CurrentDatabase
};
TestHarness.RunSqlCommandWithoutTransaction(creds, "CREATE TABLE [dbo].[testTable]" +
"(" +
"id INT IDENTITY(1, 1) NOT NULL," +
"configuration_group VARCHAR(150) NOT NULL," +
"configuration_subgroup VARCHAR(150) NOT NULL," +
"name VARCHAR(150) NOT NULL," +
"value VARCHAR(max) NULL, " +
"visible BIT NOT NULL DEFAULT 0" +
");");
dataStore.AddToDataStore("SqlConfigTable", "testTable");
var response = TestHarness.ExecuteAction("Microsoft-SetConfigValueInSql", dataStore);
Assert.IsTrue(response.Status == ActionStatus.Success);
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var workspaceName = request.DataStore.GetValue("WorkspaceName");
var experimentName = request.DataStore.GetValue("ExperimentName");
string sqlConnectionString = request.DataStore.GetValueAtIndex("SqlConnectionString", "SqlServerIndex");
sqlCredentials = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
ManagementSDK azuremlClient = new ManagementSDK();
var workspaces = azuremlClient.GetWorkspacesFromRdfe(azureToken, subscription);
var workspace = workspaces.SingleOrDefault(p => p.Name.ToLowerInvariant() == workspaceName.ToLowerInvariant());
if (workspace == null)
{
return(new ActionResponse(ActionStatus.Failure, null, null, string.Empty, "Workspace not found"));
}
var workspaceSettings = new WorkspaceSetting()
{
AuthorizationToken = workspace.AuthorizationToken.PrimaryToken,
Location = workspace.Region,
WorkspaceId = workspace.Id
};
var experiments = azuremlClient.GetExperiments(workspaceSettings);
var experiment = experiments.LastOrDefault(p => p.Description.ToLowerInvariant() == experimentName.ToLowerInvariant());
if (experiment == null)
{
return(new ActionResponse(ActionStatus.Failure, null, null, string.Empty, "Experiment not found"));
}
string rawJson = string.Empty;
Experiment exp = azuremlClient.GetExperimentById(workspaceSettings, experiment.ExperimentId, out rawJson);
rawJson = this.ReplaceConnectionString(rawJson);
azuremlClient.SaveExperiment(workspaceSettings, exp, rawJson);
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string server = request.DataStore.GetJson("SqlCredentials")["Server"].ToString();
string user = request.DataStore.GetJson("SqlCredentials").SelectToken("User")?.ToString();
string password = request.DataStore.GetJson("SqlCredentials").SelectToken("Password")?.ToString();
var auth = request.DataStore.GetJson("SqlCredentials")["AuthType"].ToString();
SqlCredentials credentials = new SqlCredentials()
{
Server = server,
Username = user,
Password = password,
Authentication = auth.EqualsIgnoreCase("Windows") ? SqlAuthentication.Windows : SqlAuthentication.SQL
};
var response = SqlUtility.GetListOfDatabases(credentials, true);
return(response.Count == 0
? new ActionResponse(ActionStatus.Failure, JsonUtility.GetEmptyJObject(), "NoDatabasesFound")
: new ActionResponse(ActionStatus.Success, JsonUtility.CreateJObjectWithValueFromObject(response)));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var sqlCreds = request.DataStore.GetJson("SqlCredentials");
string server = sqlCreds.SelectToken("Server")?.ToString();
string user = sqlCreds.SelectToken("User")?.ToString();
string password = sqlCreds.SelectToken("Password")?.ToString();
var auth = sqlCreds.SelectToken("AuthType")?.ToString();
var database = sqlCreds.SelectToken("Database")?.ToString();
SqlCredentials credentials = new SqlCredentials()
{
Server = server,
Username = user,
Password = password,
Authentication = auth.EqualsIgnoreCase("Windows") ? SqlAuthentication.Windows : SqlAuthentication.SQL,
Database = string.IsNullOrEmpty(database) ? "master" : database
};
var response = SqlUtility.GetConnectionString(credentials);
return(new ActionResponse(ActionStatus.Success, JsonUtility.CreateJObjectWithValueFromObject(response), true));
}
public PowerAppSqlConnectionProperties(SqlCredentials sqlCredentials, string environmentId)
{
ConnectionParameters = new PowerAppSqlConnectionPropertiesConnectionParameters(sqlCredentials);
Environment = new PowerAppEnvironment(environmentId);
}
public static DataTable InvokeStoredProcedure(SqlCredentials credentials, string script, Dictionary <string, string> args)
{
return(InvokeStoredProcedure(GetConnectionString(credentials), script, args));
}
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.GetLastValue("SqlLocation") ?? "westus";
var databaseTier = request.DataStore.GetLastValue("SqlSku") ?? "S1";
string server = request.DataStore.GetJson("SqlCredentials").SelectToken("Server")?.ToString();
string user = request.DataStore.GetJson("SqlCredentials").SelectToken("User")?.ToString();
string password = request.DataStore.GetJson("SqlCredentials").SelectToken("Password")?.ToString();
var database = request.DataStore.GetJson("SqlCredentials").SelectToken("Database")?.ToString();
string serverWithoutExtension = server.Replace(".database.windows.net", string.Empty);
var param = new AzureArmParameterGenerator();
param.AddStringParam("SqlServerName", serverWithoutExtension);
param.AddStringParam("SqlDatabaseName", database);
param.AddStringParam("Username", user);
param.AddParameter("Password", "securestring", password);
param.AddStringParam("Sku", databaseTier);
param.AddStringParam("SqlLocation", location);
var armTemplate = JsonUtility.GetJObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.ControllerModel.SiteCommonFilePath, "Service/Arm/sqlserveranddatabase.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
ResourceManagementClient client = new ResourceManagementClient(creds);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = armTemplate.ToString(),
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
string deploymentName = "SqlDatabaseDeployment";
var validate = await client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken());
if (!validate.IsValid)
{
return(new ActionResponse(
ActionStatus.Failure,
JsonUtility.GetJObjectFromObject(validate),
null,
DefaultErrorCodes.DefaultErrorCode,
$"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
var deploymentItem = await client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken());
// Wait for deployment
while (true)
{
Thread.Sleep(5000);
var status = await client.Deployments.GetAsync(resourceGroup, deploymentName, new CancellationToken());
var operations = await client.DeploymentOperations.ListAsync(resourceGroup, deploymentName, new DeploymentOperationsListParameters());
var provisioningState = status.Deployment.Properties.ProvisioningState;
if (provisioningState == "Accepted" || provisioningState == "Running")
{
continue;
}
if (provisioningState == "Succeeded")
{
break;
}
var operation = operations.Operations.First(p => p.Properties.ProvisioningState == ProvisioningState.Failed);
var operationFailed = await client.DeploymentOperations.GetAsync(resourceGroup, deploymentName, operation.OperationId);
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(operationFailed), null, DefaultErrorCodes.DefaultErrorCode, operationFailed.Operation.Properties.StatusMessage));
}
SqlCredentials credentials = new SqlCredentials()
{
Server = server,
Username = user,
Password = password,
Authentication = SqlAuthentication.SQL,
Database = database
};
var connectionStringResponse = SqlUtility.GetConnectionString(credentials);
return(new ActionResponse(ActionStatus.Success, JsonUtility.CreateJObjectWithValueFromObject(connectionStringResponse), true));
}
public PowerAppSqlConnection(SqlCredentials sqlCredentials, string environmentId)
{
Properties = new PowerAppSqlConnectionProperties(sqlCredentials, environmentId);
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
var subscription = request.DataStore.GetJson("SelectedSubscription")["SubscriptionId"].ToString();
var webserviceFile = request.DataStore.GetValue("WebServiceFile");
var webserviceName = request.DataStore.GetValue("WebServiceName");
var commitmentPlanName = request.DataStore.GetValue("CommitmentPlan");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var storageAccountName = request.DataStore.GetValue("StorageAccountName");
string sqlConnectionString = request.DataStore.GetValueAtIndex("SqlConnectionString", "SqlServerIndex");
SqlCredentials sqlCredentials = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
ServiceClientCredentials creds = new TokenCredentials(azureToken);
AzureMLWebServicesManagementClient client = new AzureMLWebServicesManagementClient(creds);
AzureMLCommitmentPlansManagementClient commitmentClient = new AzureMLCommitmentPlansManagementClient(creds);
client.SubscriptionId = subscription;
commitmentClient.SubscriptionId = subscription;
// Create commitment plan
var commitmentPlan = new Azure.Management.MachineLearning.CommitmentPlans.Models.CommitmentPlan();
commitmentPlan.Sku = new ResourceSku()
{
Capacity = 1,
Name = "S1",
Tier = "Standard"
};
commitmentPlan.Location = "South Central US";
var createdsCommitmentPlan = await commitmentClient.CommitmentPlans.CreateOrUpdateAsync(commitmentPlan, resourceGroup, commitmentPlanName);
// Get key from storage account
var response = await RequestUtility.CallAction(request, "Microsoft-GetStorageAccountKey");
var responseObject = JsonUtility.GetJObjectFromObject(response.Body);
string key = responseObject["StorageAccountKey"].ToString();
// Get webservicedefinition
string jsonDefinition = File.ReadAllText(request.Info.App.AppFilePath + "/" + webserviceFile);
string jsonFinal = ReplaceSqlPasswords(sqlCredentials, jsonDefinition);
// Create WebService - fixed to southcentralus
WebService webService = ModelsSerializationUtil.GetAzureMLWebServiceFromJsonDefinition(jsonFinal);
webService.Properties.StorageAccount = new StorageAccount
{
Key = key,
Name = storageAccountName
};
webService.Properties.CommitmentPlan = new CommitmentPlan(createdsCommitmentPlan.Id);
webService.Name = webserviceName;
var result = await client.WebServices.CreateOrUpdateAsync(resourceGroup, webserviceName, webService);
var keys = await client.WebServices.ListKeysAsync(resourceGroup, webserviceName);
var swaggerLocation = result.Properties.SwaggerLocation;
string url = swaggerLocation.Replace("swagger.json", "jobs?api-version=2.0");
string serviceKey = keys.Primary;
request.DataStore.AddToDataStore("AzureMLUrl", url);
request.DataStore.AddToDataStore("AzureMLKey", serviceKey);
return(new ActionResponse(ActionStatus.Success));
}
