public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
int sqlIndex = 0;
if (request.DataStore.KeyExists("SqlServerIndex"))
{
sqlIndex = int.Parse(request.DataStore.GetValue("SqlServerIndex"));
}
var filename = request.DataStore.GetValue("FileName");
string connectionString = request.DataStore.GetAllValues("SqlConnectionString")[sqlIndex];
var templateFullPath = request.Info.App.AppFilePath + $"/service/PowerBI/{filename}";
var tempfileName = Path.GetRandomFileName();
var templateTempFullPath = request.Info.App.AppFilePath + $"/Temp/{tempfileName}/{filename}";
Directory.CreateDirectory(request.Info.App.AppFilePath + $"/Temp/{tempfileName}");
var creds = SqlUtility.GetSqlCredentialsFromConnectionString(connectionString);
using (PBIXUtils wrangler = new PBIXUtils(templateFullPath, templateTempFullPath))
{
wrangler.ReplaceKnownVariableinMashup("STSqlServer", creds.Server);
wrangler.ReplaceKnownVariableinMashup("STSqlDatabase", creds.Database);
}
string serverPath = request.Info.ServiceRootUrl + request.Info.ServiceRelativePath + request.Info.App.AppRelativeFilePath + $"/Temp/{tempfileName}/{filename}";
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetJObjectFromStringValue(serverPath)));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureTokenAS");
string serverUrl = request.DataStore.GetValue("ASServerUrl");
string xmla = request.DataStore.GetValue("xmlaFilePath");
string asDatabase = request.DataStore.GetValue("ASDatabase");
string sqlConnectionString = request.DataStore.GetValue("SqlConnectionString");
var connectionStringObj = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
string connectionString = ValidateConnectionToAS.GetASConnectionString(request, azureToken, serverUrl);
string xmlaContents = File.ReadAllText(request.Info.App.AppFilePath + "/" + xmla);
Server server = null;
try
{
server = new Server();
server.Connect(connectionString);
// Delete existing
Database db = server.Databases.FindByName(asDatabase);
db?.Drop();
// Deploy database definition
var obj = JsonUtility.GetJsonObjectFromJsonString(xmlaContents);
obj["create"]["database"]["name"] = asDatabase;
XmlaResultCollection response = server.Execute(obj.ToString());
if (response.ContainsErrors)
{
return(new ActionResponse(ActionStatus.Failure, response[0].Value));
}
// Reload metadata and update connection string
server.Refresh(true);
db = server.Databases.FindByName(asDatabase);
((ProviderDataSource)db.Model.DataSources[0]).ConnectionString = $"Provider=SQLNCLI11;Data Source=tcp:{connectionStringObj.Server};Persist Security Info=True;User ID={connectionStringObj.Username};Password={connectionStringObj.Password};Initial Catalog={connectionStringObj.Database}";
db.Update(UpdateOptions.ExpandFull);
// Process if there's a tag requesting it
if (db.Model.DataSources[0].Annotations.ContainsName("MustProcess"))
{
db.Model.RequestRefresh(AnalysisServices.Tabular.RefreshType.Full);
db.Model.SaveChanges();
}
server.Disconnect(true);
return(new ActionResponse(ActionStatus.Success));
}
catch (Exception e)
{
return(new ActionResponse(ActionStatus.Failure, string.Empty, e, null));
}
finally
{
server?.Dispose();
}
}
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 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)
{
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)));
}
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 apiConnectionName = request.DataStore.GetValue("ApiConnectionName");
var connectionName = apiConnectionName == null ? "sql" : apiConnectionName;
var connectionString = request.DataStore.GetValue("SqlConnectionString");
var conn = SqlUtility.GetSqlCredentialsFromConnectionString(connectionString);
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
Microsoft.Azure.Management.Resources.ResourceManagementClient client = new ResourceManagementClient(creds);
var registration = await client.Providers.RegisterAsync("Microsoft.Web");
dynamic payload = new ExpandoObject();
payload.properties = new ExpandoObject();
payload.properties.parameterValues = new ExpandoObject();
payload.properties.parameterValues.sku = "Enterprise";
payload.properties.displayName = connectionName;
payload.properties.parameterValues = new ExpandoObject();
payload.properties.parameterValues.server = conn.Server;
payload.properties.parameterValues.database = conn.Database;
payload.properties.parameterValues.password = conn.Password;
payload.properties.parameterValues.username = conn.Username;
payload.properties.api = new ExpandoObject();
payload.properties.api.id = $"subscriptions/{subscription}/providers/Microsoft.Web/locations/{location}/managedApis/sql";
payload.location = location;
HttpResponseMessage connection = await new AzureHttpClient(azureToken, subscription, resourceGroup).ExecuteWithSubscriptionAndResourceGroupAsync(HttpMethod.Put,
$"/providers/Microsoft.Web/connections/{connectionName}", "2016-06-01", JsonUtility.GetJsonStringFromObject(payload));
var output = await connection.Content.ReadAsStringAsync();
var objOutput = JsonUtility.GetJObjectFromJsonString(output);
// Retry one more time if initial deployment didn't succeed
if (objOutput["error"] != null && objOutput["error"].Value <string>("code") == "SubscriptionNotFound")
{
Thread.Sleep(new TimeSpan(0, 0, 5));
connection = await new AzureHttpClient(azureToken, subscription, resourceGroup).ExecuteWithSubscriptionAndResourceGroupAsync(HttpMethod.Put,
$"/providers/Microsoft.Web/connections/{connectionName}", "2016-06-01", JsonUtility.GetJsonStringFromObject(payload));
}
if (!connection.IsSuccessStatusCode)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromJsonString(await connection.Content.ReadAsStringAsync()),
null, DefaultErrorCodes.DefaultErrorCode, "Failed to create connection"));
}
request.DataStore.AddToDataStore("sqlConnectionName", connectionName);
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string xmla = request.DataStore.GetValue("xmlaFilePath");
string asDatabase = request.DataStore.GetValue("ASDatabase");
string sqlConnectionString = request.DataStore.GetValue("SqlConnectionString");
var connectionStringObj = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
string connectionString = request.DataStore.GetValue("ASConnectionString");
Server server = new Server();
server.Connect(connectionString);
string xmlaContents = File.ReadAllText(request.Info.App.AppFilePath + "/" + xmla);
var obj = JsonUtility.GetJsonObjectFromJsonString(xmlaContents);
obj["create"]["database"]["name"] = asDatabase;
//obj["create"]["database"]["model"]["dataSources"][0]["name"] = "Sql Connection for" + asDatabase;
obj["create"]["database"]["model"]["dataSources"][0]["connectionString"] =
$"Provider=SQLNCLI11.1;Persist Security Info=False;User ID={connectionStringObj.Username};Password={connectionStringObj.Password};" +
$"Initial Catalog={connectionStringObj.Database};Data Source=tcp:{connectionStringObj.Server};Initial File Name=;Server SPN=";
//Delete existing
var db = server.Databases.Find(asDatabase);
db?.Drop(DropOptions.Default);
server.Refresh(true);
//Deploy
var response = server.Execute(obj.ToString());
if (response.ContainsErrors)
{
return(new ActionResponse(ActionStatus.Failure, response[0].Value));
}
server = new Server();
server.Connect(connectionString);
db = server.Databases.Find(asDatabase);
if (db == null)
{
return(new ActionResponse(ActionStatus.Failure, string.Empty, null, null, "AS Database was not deployed"));
}
return(new ActionResponse(ActionStatus.Success));
}
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 override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string xmla = request.DataStore.GetValue("xmlaFilePath");
string asDatabase = request.DataStore.GetValue("ASDatabase");
string sqlConnectionString = request.DataStore.GetValue("SqlConnectionString");
var connectionStringObj = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
string connectionString = request.DataStore.GetValue("ASConnectionString");
string xmlaContents = File.ReadAllText(request.Info.App.AppFilePath + "/" + xmla);
using (Server server = new Server())
{
try
{
server.Connect(connectionString);
// Delete existing
Database db = server.Databases.FindByName(asDatabase);
db?.Drop();
// Deploy database definition
XmlaResultCollection response = server.Execute(xmlaContents);
if (response.ContainsErrors)
{
return(new ActionResponse(ActionStatus.Failure, response[0].Value));
}
// Reload metadata and update connection string
server.Refresh(true);
db = server.Databases.FindByName(asDatabase);
((ProviderDataSource)db.Model.DataSources[0]).ConnectionString = $"Provider=SQLNCLI11;Data Source=tcp:{connectionStringObj.Server};Persist Security Info=True;User ID={connectionStringObj.Username};Password={connectionStringObj.Password};Initial Catalog={connectionStringObj.Database}";
db.Update(UpdateOptions.ExpandFull);
}
catch (Exception e)
{
return(new ActionResponse(ActionStatus.Failure, string.Empty, e, null, "AS Database was not deployed"));
}
server.Disconnect(true);
}
return(new ActionResponse(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)
{
List <Task <ActionResponse> > task = new List <Task <ActionResponse> >();
var token = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
var subscription = request.DataStore.GetJson("SelectedSubscription")["SubscriptionId"].ToString();
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string schema = "dbo";
string postDeploymentPipelineType = request.DataStore.GetValue("postDeploymentPipelineType");
string pipelineFrequency = request.DataStore.GetValue("pipelineFrequency");
string pipelineInterval = request.DataStore.GetValue("pipelineInterval");
string pipelineType = request.DataStore.GetValue("pipelineType");
string pipelineStart = request.DataStore.GetValue("pipelineStart");
string pipelineEnd = request.DataStore.GetValue("pipelineEnd");
string connString = request.DataStore.GetValue("SqlConnectionString");
string sfUsername = request.DataStore.GetValue("SalesforceUser");
string sfPassword = request.DataStore.GetValue("SalesforcePassword");
string sfToken = request.DataStore.GetValue("SalesforceToken");
if (!string.IsNullOrWhiteSpace(postDeploymentPipelineType))
{
pipelineFrequency = request.DataStore.GetValue("postDeploymentPipelineFrequency");
pipelineType = postDeploymentPipelineType;
pipelineInterval = request.DataStore.GetValue("postDeploymentPipelineInterval");
}
string adfJsonData = request.DataStore.GetValue("ADFPipelineJsonData");
var sqlCreds = SqlUtility.GetSqlCredentialsFromConnectionString(connString);
var obj = JsonConvert.DeserializeObject(adfJsonData, typeof(DeserializedADFPayload)) as DeserializedADFPayload;
foreach (var o in obj.fields)
{
var deploymentName = string.Concat("ADFDataset", pipelineType, o.Item1);
dynamic datasetParam = new AzureArmParameterGenerator();
datasetParam.AddStringParam("dataFactoryName", resourceGroup + "SalesforceCopyFactory");
datasetParam.AddStringParam("sqlServerName", sqlCreds.Server.Split('.')[0]);
datasetParam.AddStringParam("sqlServerUsername", sqlCreds.Username);
datasetParam.AddStringParam("targetDatabaseName", sqlCreds.Database);
datasetParam.AddStringParam("targetSqlSchema", schema);
datasetParam.AddStringParam("targetSqlTable", o.Item1);
datasetParam.AddStringParam("salesforceUsername", sfUsername);
datasetParam.AddStringParam("targetSalesforceTable", o.Item1);
datasetParam.AddStringParam("pipelineName", o.Item1 + "CopyPipeline");
datasetParam.AddStringParam("sqlWritableTypeName", o.Item1 + "Type");
datasetParam.AddStringParam("sqlWriterStoredProcedureName", "spMerge" + o.Item1);
datasetParam.AddStringParam("pipelineStartDate", pipelineStart);
datasetParam.AddStringParam("pipelineEndDate", pipelineEnd);
datasetParam.AddStringParam("sliceFrequency", pipelineFrequency);
datasetParam.AddStringParam("sliceInterval", pipelineInterval);
datasetParam.AddStringParam("pipelineType", pipelineType);
datasetParam.AddParameter("salesforcePassword", "securestring", sfPassword);
datasetParam.AddParameter("sqlServerPassword", "securestring", sqlCreds.Password);
datasetParam.AddParameter("salesforceSecurityToken", "securestring", sfToken);
var armTemplate = JsonUtility.GetJsonObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.Info.App.AppFilePath, "Service/ADF/datasets.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(datasetParam.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
string tableFields = JsonConvert.SerializeObject(o.Item2);
StringBuilder query = CreateQuery(o, tableFields);
string stringTemplate = ReplaceTableFieldsAndQuery(tableFields, query, armTemplate);
var creds = new TokenCloudCredentials(subscription, token);
var client = new ResourceManagementClient(creds);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = stringTemplate,
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
var validate = client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
if (!validate.IsValid)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(validate), null,
DefaultErrorCodes.DefaultErrorCode, $"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
task.Add(new Task <ActionResponse>(() =>
{
var deploymentItem = client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
var helper = new DeploymentHelper();
return(helper.WaitForDeployment(resourceGroup, deploymentName, client));
}));
}
foreach (var t in task)
{
t.Start();
}
Task.WaitAll(task.ToArray());
foreach (var t in task)
{
if (t.Result.Status != ActionStatus.Success)
{
return(new ActionResponse(ActionStatus.Failure, t.Result.ExceptionDetail.FriendlyErrorMessage));
}
}
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var token = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string sfUsername = request.DataStore.GetValue("SalesforceUser");
string sfPassword = request.DataStore.GetValue("SalesforcePassword");
string sfToken = request.DataStore.GetValue("SalesforceToken");
string sfUrl = request.DataStore.GetValue("SalesforceUrl");
string fullServerUrl = request.DataStore.GetValue("SalesforceBaseUrl");
string connString = request.DataStore.GetValue("SqlConnectionString");
string emails = request.DataStore.GetValue("EmailAddresses");
string dataFactoryName = resourceGroup + "SalesforceCopyFactory";
var param = new AzureArmParameterGenerator();
var sqlCreds = SqlUtility.GetSqlCredentialsFromConnectionString(connString);
param.AddStringParam("dataFactoryName", dataFactoryName);
param.AddStringParam("sqlServerFullyQualifiedName", sqlCreds.Server);
param.AddStringParam("sqlServerUsername", sqlCreds.Username);
param.AddStringParam("targetDatabaseName", sqlCreds.Database);
param.AddStringParam("salesforceUsername", sfUsername);
param.AddStringParam("subscriptionId", subscription);
param.AddStringParam("environmentUrl", sfUrl);
param.AddParameter("salesforcePassword", "securestring", sfPassword);
param.AddParameter("sqlServerPassword", "securestring", sqlCreds.Password);
param.AddParameter("salesforceSecurityToken", "securestring", sfToken);
var armTemplate = JsonUtility.GetJsonObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.Info.App.AppFilePath, "Service/ADF/linkedServices.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
if (string.IsNullOrEmpty(emails))
{
(armTemplate
.SelectToken("resources")[0]
.SelectToken("resources") as JArray)
.RemoveAt(2);
}
else
{
var addresses = emails.Split(',');
List <string> adr = new List <string>();
foreach (var address in addresses)
{
adr.Add(address);
}
var stringTemplate = armTemplate.ToString();
stringTemplate = stringTemplate.Replace("\"EMAILS\"", JsonConvert.SerializeObject(adr));
armTemplate = JsonUtility.GetJObjectFromJsonString(stringTemplate);
}
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, token);
ResourceManagementClient client = new ResourceManagementClient(creds);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = armTemplate.ToString(),
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
var factoryIdenity = new ResourceIdentity
{
ResourceProviderApiVersion = "2015-10-01",
ResourceName = dataFactoryName,
ResourceProviderNamespace = "Microsoft.DataFactory",
ResourceType = "datafactories"
};
var factory = client.Resources.CheckExistence(resourceGroup, factoryIdenity);
if (factory.Exists)
{
client.Resources.Delete(resourceGroup, factoryIdenity);
}
string deploymentName = "SalesforceCopyFactory-linkedServices";
var validate = client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
if (!validate.IsValid)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(validate), null,
DefaultErrorCodes.DefaultErrorCode, $"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
var deploymentItem = client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
var helper = new DeploymentHelper();
return(helper.WaitForDeployment(resourceGroup, deploymentName, client));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string azureToken = request.DataStore.GetJson("AzureToken", "access_token");
string subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
string webserviceFile = request.DataStore.GetValue("WebServiceFile");
string webserviceName = request.DataStore.GetValue("WebServiceName");
string commitmentPlanName = request.DataStore.GetValue("CommitmentPlan");
string resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string storageAccountName = request.DataStore.GetValue("StorageAccountName");
string storageAccountKey = request.DataStore.GetValue("StorageAccountKey");
string responseType = request.DataStore.GetValue("IsRequestResponse");
bool isRequestResponse = false;
if (responseType != null)
{
isRequestResponse = bool.Parse(responseType);
}
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 createdCommitmentPlan = await commitmentClient.CommitmentPlans.CreateOrUpdateAsync(commitmentPlan, resourceGroup, commitmentPlanName);
request.Logger.LogResource(request.DataStore, createdCommitmentPlan.Name,
DeployedResourceType.MlWebServicePlan, CreatedBy.BPST, DateTime.UtcNow.ToString("o"), createdCommitmentPlan.Id, commitmentPlan.Sku.Tier);
// Get webservicedefinition
string sqlConnectionString = request.DataStore.GetValueAtIndex("SqlConnectionString", "SqlServerIndex");
SqlCredentials sqlCredentials;
string jsonDefinition = File.ReadAllText(request.Info.App.AppFilePath + "/" + webserviceFile);
if (!string.IsNullOrWhiteSpace(sqlConnectionString))
{
sqlCredentials = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
jsonDefinition = ReplaceSqlPasswords(sqlCredentials, jsonDefinition);
}
// Create WebService - fixed to southcentralus
WebService webService = ModelsSerializationUtil.GetAzureMLWebServiceFromJsonDefinition(jsonDefinition);
webService.Properties.StorageAccount = new StorageAccount
{
Key = storageAccountKey,
Name = storageAccountName
};
webService.Properties.CommitmentPlan = new CommitmentPlan(createdCommitmentPlan.Id);
// A little bit of juggling to change the name
webService = new WebService(webService.Location, webService.Properties, null, webserviceName, webService.Type, webService.Tags);
WebService result = null;
try
{
result = client.WebServices.CreateOrUpdate(resourceGroup, webserviceName, webService);
var keys = client.WebServices.ListKeys(resourceGroup, webserviceName);
var swaggerLocation = result.Properties.SwaggerLocation;
string url = swaggerLocation.Replace("swagger.json", "jobs?api-version=2.0");
if (isRequestResponse)
{
url = swaggerLocation.Replace("swagger.json", "execute?api-version=2.0&format=swagger");
}
string serviceKey = keys.Primary;
request.DataStore.AddToDataStore("AzureMLUrl", url);
request.DataStore.AddToDataStore("AzureMLKey", serviceKey);
}
catch (CloudException e)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromStringValue(e.Message), e, "DefaultError", ((CloudException)e).Response.Content));
}
request.Logger.LogResource(request.DataStore, result.Name,
DeployedResourceType.MlWebService, CreatedBy.BPST, DateTime.UtcNow.ToString("o"), result.Id);
return(new ActionResponse(ActionStatus.Success));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
List <Task <ActionResponse> > task = new List <Task <ActionResponse> >();
var token = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string connString = request.DataStore.GetValue("SqlConnectionString");
string schema = "dbo";
string postDeploymentPipelineType = request.DataStore.GetValue("postDeploymentPipelineType");
string pipelineFrequency = request.DataStore.GetValue("pipelineFrequency");
string pipelineInterval = request.DataStore.GetValue("pipelineInterval");
string pipelineType = request.DataStore.GetValue("pipelineType");
string pipelineStart = request.DataStore.GetValue("pipelineStart");
string pipelineEnd = request.DataStore.GetValue("pipelineEnd");
bool historicalOnly = Convert.ToBoolean(request.DataStore.GetValue("historicalOnly"));
string dataFactoryName = resourceGroup.Replace("_", string.Empty) + "SalesforceCopyFactory";
if (!string.IsNullOrWhiteSpace(postDeploymentPipelineType))
{
pipelineFrequency = request.DataStore.GetValue("postDeploymentPipelineFrequency");
pipelineType = postDeploymentPipelineType;
pipelineInterval = request.DataStore.GetValue("postDeploymentPipelineInterval");
pipelineStart = DateTime.UtcNow.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
pipelineEnd = new DateTime(9999, 12, 31, 23, 59, 59).ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
}
if (string.IsNullOrWhiteSpace(pipelineStart))
{
pipelineStart = DateTime.UtcNow.AddYears(-3).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
}
if (string.IsNullOrWhiteSpace(pipelineEnd))
{
pipelineEnd = DateTime.UtcNow.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
}
var adfJsonData = request.DataStore.GetValue("ADFPipelineJsonData");
var obj = JsonConvert.DeserializeObject(adfJsonData, typeof(DeserializedADFPayload)) as DeserializedADFPayload;
obj = ReorderObjects(obj);
for (int i = 0; i < obj.fields.Count(); i++)
{
var o = obj.fields[i];
string deploymentName = string.Concat("ADFPipeline", pipelineType, o.Item1);
var sqlCreds = SqlUtility.GetSqlCredentialsFromConnectionString(connString);
var param = new AzureArmParameterGenerator();
param.AddStringParam("dataFactoryName", dataFactoryName);
param.AddStringParam("targetSqlSchema", schema);
param.AddStringParam("targetSqlTable", o.Item1.ToLowerInvariant());
param.AddStringParam("targetSalesforceTable", o.Item1);
param.AddStringParam("pipelineName", o.Item1 + "_CopyPipeline");
param.AddStringParam("sqlWritableTypeName", o.Item1.ToLowerInvariant() + "type");
param.AddStringParam("sqlWriterStoredProcedureName", "spMerge" + o.Item1.ToLowerInvariant());
param.AddStringParam("pipelineStartDate", pipelineStart);
param.AddStringParam("pipelineEndDate", pipelineEnd);
param.AddStringParam("pipelineType", pipelineType);
param.AddStringParam("sliceFrequency", pipelineFrequency);
param.AddStringParam("sliceInterval", pipelineInterval);
var armTemplate = JsonUtility.GetJsonObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.Info.App.AppFilePath, "Service/ADF/pipeline.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
if (i >= 1)
{
armTemplate = CreatePipelineDependency(pipelineType, obj, armTemplate, i - 1);
}
string tableFields = JsonConvert.SerializeObject(o.Item2);
StringBuilder query;
if (o.Item1 != "Opportunity" &&
o.Item1 != "Lead" &&
o.Item1 != "OpportunityLineItem" &&
pipelineType == "PreDeployment")
{
query = CreateQuery(o, tableFields, true, pipelineStart, pipelineEnd);
armTemplate = CreateOneTimePipeline(armTemplate);
}
else
{
query = CreateQuery(o, tableFields, false);
}
if (historicalOnly && pipelineType == "PostDeployment")
{
armTemplate = this.PausePipeline(armTemplate);
}
string stringTemplate = ReplaceTableFieldsAndQuery(tableFields, query, armTemplate);
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, token);
ResourceManagementClient client = new ResourceManagementClient(creds);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = stringTemplate,
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
var validate = client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
if (!validate.IsValid)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(validate), null,
DefaultErrorCodes.DefaultErrorCode, $"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
task.Add(new Task <ActionResponse>(() =>
{
var deploymentItem = client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
var helper = new DeploymentHelper();
return(helper.WaitForDeployment(resourceGroup, deploymentName, client));
}));
}
foreach (var t in task)
{
t.Start();
}
Task.WaitAll(task.ToArray());
foreach (var t in task)
{
if (t.Result.Status != ActionStatus.Success)
{
return(new ActionResponse(ActionStatus.Failure, t.Result.ExceptionDetail.FriendlyErrorMessage));
}
}
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetJObjectFromStringValue(dataFactoryName)));
}
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));
}
public async Task NewsTemplateDeployment()
{
var dataStore = await TestHarness.GetCommonDataStoreWithUserToken();
#region DeploySQLScripts
// Deploy SQL Scripts
dataStore.AddToDataStore("SqlConnectionString", TestHarness.GetSqlPagePayload("NewsTemplateTest"));
dataStore.AddToDataStore("SqlServerIndex", "0");
dataStore.AddToDataStore("SqlScriptsFolder", "Service/Database");
var response = await TestHarness.ExecuteActionAsync("Microsoft-DeploySQLScripts", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.Status == ActionStatus.Success);
#endregion
#region DeployFunction
//// Deploy Function
dataStore.AddToDataStore("DeploymentName", "FunctionDeploymentTest");
dataStore.AddToDataStore("FunctionName", "unittestfunction" + TestHarness.RandomCharacters);
dataStore.AddToDataStore("RepoUrl", "https://github.com/juluczni/AzureFunctionsNewsTemplate");
response = TestHarness.ExecuteAction("Microsoft-DeployAzureFunction", dataStore);
Assert.IsTrue(response.IsSuccess);
response = TestHarness.ExecuteAction("Microsoft-WaitForArmDeploymentStatus", dataStore);
Assert.IsTrue(response.IsSuccess);
// FTP File Function
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployPrivateAssemblyToFunction", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
#endregion
#region DeployStorageAccount
//// Create Storage Account
dataStore.AddToDataStore("DeploymentName", "StorageDeploymentTest");
dataStore.AddToDataStore("StorageAccountName", "unitteststorage" + TestHarness.RandomCharacters);
dataStore.AddToDataStore("StorageAccountType", "Standard_LRS");
dataStore.AddToDataStore("StorageAccountEncryptionEnabled", "false");
response = await TestHarness.ExecuteActionAsync("Microsoft-CreateAzureStorageAccount", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-WaitForArmDeploymentStatus", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
//Get key
response = await TestHarness.ExecuteActionAsync("Microsoft-GetStorageAccountKey", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-WaitForArmDeploymentStatus", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
//Deploy blob
dataStore.AddToDataStore("StorageAccountContainer", "newsimages");
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployStorageAccountContainer", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
#endregion
#region AMLWEBServiceDeployment
// Deploy experiments
dataStore.AddToDataStore("CommitmentPlan", "motestcomm");
dataStore.AddToDataStore("Replace", "WebServiceFile", "Service/AzureML/Experiments/TopicsWebService.json");
dataStore.AddToDataStore("Replace", "WebServiceName", "Topics" + TestHarness.RandomCharacters);
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployAzureMLWebServiceFromFile", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.Status == ActionStatus.Success);
dataStore.CurrentRoutePage = "1";
dataStore.AddToDataStore("Replace", "WebServiceFile", "Service/AzureML/Experiments/TopicImagesWebService.json");
dataStore.AddToDataStore("Replace", "WebServiceName", "TopicImages" + TestHarness.RandomCharacters);
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployAzureMLWebServiceFromFile", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.Status == ActionStatus.Success);
dataStore.CurrentRoutePage = "2";
dataStore.AddToDataStore("Replace", "WebServiceFile", "Service/AzureML/Experiments/EntityWebService.json");
dataStore.AddToDataStore("Replace", "WebServiceName", "Entity" + TestHarness.RandomCharacters);
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployAzureMLWebServiceFromFile", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.Status == ActionStatus.Success);
#endregion
#region DeployConnectors
//Deploy Text Analytics Service
dataStore.AddToDataStore("DeploymentName", "CongitiveServiceDeployText");
dataStore.AddToDataStore("CognitiveServiceName", "TestCognitiveService");
dataStore.AddToDataStore("CognitiveServiceType", "TextAnalytics");
dataStore.AddToDataStore("CognitiveSkuName", "S1");
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployCognitiveService", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
//Get Key for Text Analytics
response = await TestHarness.ExecuteActionAsync("Microsoft-GetCognitiveKey", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
//Create connector for Text Analytics
dataStore.AddToDataStore("ConnectorName", "cognitiveservicestextanalytics");
dynamic payload = new ExpandoObject();
payload.apiKey = dataStore.GetValue("CognitiveServiceKey");
payload = JsonUtility.GetJObjectFromObject(payload);
dataStore.AddToDataStore("ConnectorPayload", payload);
dataStore.AddToDataStore("ConnectorDisplayName", "TextAnalytics");
//response = await TestHarness.ExecuteActionAsync("Microsoft-CreateConnectorToLogicApp", dataStore, "Microsoft-NewsTemplateTest");
//Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-UpdateBlobStorageConnector", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
dataStore.AddToDataStore("KeyNumber", "1");
//Deploy Bing Cognitive Service
dataStore.AddToDataStore("DeploymentName", "CongitiveServiceDeployBing");
dataStore.AddToDataStore("CognitiveServiceName", "TestCognitiveService2");
dataStore.AddToDataStore("CognitiveServiceType", "Bing.Search");
dataStore.AddToDataStore("CognitiveSkuName", "S1");
dataStore.AddToDataStore("CognitiveServiceKey", "");
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployCognitiveService", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
//Get Key for Bing
response = await TestHarness.ExecuteActionAsync("Microsoft-GetCognitiveKey", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
//Create connector for Bing News
dataStore.AddToDataStore("ConnectorName", "bingsearch");
payload = new ExpandoObject();
payload.apiKey = dataStore.GetValue("CognitiveServiceKey");
payload = JsonUtility.GetJObjectFromObject(payload);
dataStore.AddToDataStore("ConnectorPayload", payload);
dataStore.AddToDataStore("ConnectorDisplayName", "bingsearch");
//response = await TestHarness.ExecuteActionAsync("Microsoft-CreateConnectorToLogicApp", dataStore, "Microsoft-NewsTemplateTest");
//Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-UpdateBlobStorageConnector", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
// Create storage account connector
dataStore.AddToDataStore("ConnectorName", "azureblob");
dataStore.AddToDataStore("ConnectorDisplayName", "azureblob");
payload = new ExpandoObject();
payload.accountName = dataStore.GetValue("StorageAccountName");
payload.accessKey = dataStore.GetValue("StorageAccountKey");
payload = JsonUtility.GetJObjectFromObject(payload);
dataStore.AddToDataStore("ConnectorPayload", payload);
//response = await TestHarness.ExecuteActionAsync("Microsoft-CreateConnectorToLogicApp", dataStore, "Microsoft-NewsTemplateTest");
//Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-UpdateBlobStorageConnector", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
//Create SQL Connector
dataStore.AddToDataStore("ConnectorName", "sql");
payload = new ExpandoObject();
string connectionString = TestHarness.GetSqlPagePayload("NewsTemplateTest");
var connectionStringObj = SqlUtility.GetSqlCredentialsFromConnectionString(connectionString);
payload.authType = "windows";
payload.database = connectionStringObj.Database;
payload.password = connectionStringObj.Password;
payload.server = connectionStringObj.Server;
payload.username = connectionStringObj.Username;
payload = JsonUtility.GetJObjectFromObject(payload);
dataStore.AddToDataStore("ConnectorPayload", payload);
dataStore.AddToDataStore("ConnectorDisplayName", "SQLConnector");
//response = await TestHarness.ExecuteActionAsync("Microsoft-CreateConnectorToLogicApp", dataStore, "Microsoft-NewsTemplateTest");
//Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-UpdateBlobStorageConnector", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
// Create AML Connector
dataStore.AddToDataStore("ConnectorName", "azureml");
dataStore.AddToDataStore("ConnectorDisplayName", "azureml");
payload = new ExpandoObject();
payload = JsonUtility.GetJObjectFromObject(payload);
dataStore.AddToDataStore("ConnectorPayload", payload);
//response = await TestHarness.ExecuteActionAsync("Microsoft-CreateConnectorToLogicApp", dataStore, "Microsoft-NewsTemplateTest");
//Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-UpdateBlobStorageConnector", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
#endregion
#region DeployLogicAppImageCache
////Image Cache Logic App
dataStore.AddToDataStore("DeploymentName", "LogicAppDeploymentTest");
dataStore.AddToDataStore("LogicAppName", "testname");
dataStore.AddToDataStore("ImageCacheLogicApp", "testname");
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployImageCachingLogicApp", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-WaitForArmDeploymentStatus", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
#endregion
#region DeployAMLLogicApp
dataStore.AddToDataStore("DeploymentName", "amllogicapp");
dataStore.AddToDataStore("LogicAppName", "AmlLogicApp");
//Create Logic App
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployAzureMLSchedulerLogicApp", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-WaitForArmDeploymentStatus", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
#endregion
#region LogicAppNewsOrchestrator
dataStore.AddToDataStore("DeploymentName", "mainlogicapp");
dataStore.AddToDataStore("LogicAppName", "MainLogicApp");
dataStore.AddToDataStore("SearchQuery", "Trump");
dataStore.AddToDataStore("ImageCacheLogicApp", "testname");
response = await TestHarness.ExecuteActionAsync("Microsoft-DeployNewsTemplateLogicApp", dataStore, "Microsoft-NewsTemplateTest");;
Assert.IsTrue(response.IsSuccess);
response = await TestHarness.ExecuteActionAsync("Microsoft-WaitForArmDeploymentStatus", dataStore, "Microsoft-NewsTemplateTest");
Assert.IsTrue(response.IsSuccess);
#endregion
}
