public async Task MigrateToCloudIA(List <SchemaMigrationItemViewModel> schemaItems, IntegrationAccountDetails iaDetails)
{
this.iaDetails = iaDetails;
ActionOnSchemas action = new ActionOnSchemas();
var schemasToBeUploaded = thisApplicationContext.GetProperty("SchemasToUploadOrder") as List <SchemaDetails>;
AuthenticationResult authresult = thisApplicationContext.GetProperty("IntegrationAccountAuthorization") as AuthenticationResult;
bool overwriteExistingArtifacts = Convert.ToBoolean(thisApplicationContext.GetProperty("OverwriteEnabled"));
List <SchemaDetails> schemaDetailsList = new List <SchemaDetails>();
foreach (var schemaItem in schemaItems)
{
schemaItem.MigrationEntity.schemaUploadToIAStatus = SchemaUploadToIAStatus.NotYetStarted;
schemaItem.MigrationEntity.errorDetailsForMigration = "";
schemaDetailsList.Add(schemaItem.MigrationEntity);
}
await Task.Factory.StartNew(() =>
{
try
{
action.UploadToIntegrationAccount(schemasToBeUploaded, ref schemaDetailsList, Resources.JsonSchemaFilesLocalPath, overwriteExistingArtifacts, iaDetails.SubscriptionId, iaDetails.ResourceGroupName, iaDetails.IntegrationAccountName, authresult);
SetMigrationStatus(schemaDetailsList, schemaItems);
}
catch (Exception ex)
{
SetMigrationStatus(schemaDetailsList, schemaItems);
TraceProvider.WriteLine(string.Format("Schemas Migration Failed. Reason:{0}", ExceptionHelper.GetExceptionMessage(ex)));
TraceProvider.WriteLine();
throw new Exception(string.Format("Schemas Migration Failed. Reason:{0}", ExceptionHelper.GetExceptionMessage(ex)));
}
});
}
public override async Task ExportToIA(PartnerMigrationItemViewModel serverPartnerItem, IntegrationAccountDetails iaDetails)
{
this.iaDetails = iaDetails;
try
{
TraceProvider.WriteLine("Migrating partner : {0}", serverPartnerItem.MigrationEntity.Name);
await Task.Factory.StartNew(() =>
{
try
{
AuthenticationResult authresult = thisApplicationContext.GetProperty("IntegrationAccountAuthorization") as AuthenticationResult;
bool overwrite = Convert.ToBoolean(thisApplicationContext.GetProperty("OverwriteEnabled"));
if (!overwrite)
{
bool exists = CheckIfArtifactExists(serverPartnerItem.MigrationEntity.Name, "Partner", this.iaDetails, authresult).Result;
if (exists)
{
serverPartnerItem.ExportStatus = MigrationStatus.Partial;
serverPartnerItem.ExportStatusText = string.Format("The Partner {0} already exists on IA with name {1}. Since the Overwrite option was disabled, the partner was not overwritten.", serverPartnerItem.MigrationEntity.Name, FileOperations.GetFileName(serverPartnerItem.MigrationEntity.Name));
TraceProvider.WriteLine(serverPartnerItem.ExportStatusText);
TraceProvider.WriteLine();
}
else
{
MigrateToCloudIAPartner(FileOperations.GetPartnerJsonFilePath(serverPartnerItem.MigrationEntity.Name), FileOperations.GetFileName(serverPartnerItem.MigrationEntity.Name), serverPartnerItem, iaDetails, authresult).Wait();
serverPartnerItem.ExportStatus = MigrationStatus.Succeeded;
StringBuilder successMessageText = new StringBuilder();
successMessageText.Append(string.Format(Resources.ExportSuccessMessageText, serverPartnerItem.MigrationEntity.Name));
serverPartnerItem.ExportStatusText = successMessageText.ToString();
TraceProvider.WriteLine(string.Format("Partner Migration Successfull: {0}", serverPartnerItem.MigrationEntity.Name));
TraceProvider.WriteLine();
}
}
else
{
MigrateToCloudIAPartner(FileOperations.GetPartnerJsonFilePath(serverPartnerItem.MigrationEntity.Name), FileOperations.GetFileName(serverPartnerItem.MigrationEntity.Name), serverPartnerItem, iaDetails, authresult).Wait();
serverPartnerItem.ExportStatus = MigrationStatus.Succeeded;
StringBuilder successMessageText = new StringBuilder();
successMessageText.Append(string.Format(Resources.ExportSuccessMessageText, serverPartnerItem.MigrationEntity.Name));
serverPartnerItem.ExportStatusText = successMessageText.ToString();
TraceProvider.WriteLine(string.Format("Partner Migration Successfull: {0}", serverPartnerItem.MigrationEntity.Name));
TraceProvider.WriteLine();
}
}
catch (Exception)
{
//throw ex;
}
});
}
catch (Exception)
{
//throw ex;
}
}
public bool Validate()
{
Debug.Assert(statusBarViewModel != null, "StatusBarViewModel has not been initialized in application context");
statusBarViewModel.Clear();
if (SelectedSubscription == null)
{
statusBarViewModel.ShowError("Please select a Subscription before proceeding");
}
if (SelectedResourceGroup == null)
{
statusBarViewModel.ShowError("Please select a Resource Group before proceeding");
}
if (SelectedIntegrationAccount == null)
{
statusBarViewModel.ShowError("Please select a Integration Account before proceeding");
}
if (!string.IsNullOrEmpty(statusBarViewModel.StatusBarText))
{
return(false);
}
var cachedintegrationAccountDetails = this.ApplicationContext.GetService <IntegrationAccountDetails>();
if (cachedintegrationAccountDetails == null)
{
var integrationAccountDetails = new IntegrationAccountDetails();
integrationAccountDetails.SubscriptionId = SelectedSubscription.SubscriptionId;
integrationAccountDetails.ResourceGroupName = SelectedResourceGroup.Name;
integrationAccountDetails.IntegrationAccountName = SelectedIntegrationAccount.Name;
if (SelectedKeyVault != null)
{
integrationAccountDetails.KeyVaultName = SelectedKeyVault.Name;
}
this.ApplicationContext.AddService(integrationAccountDetails);
}
else
{
cachedintegrationAccountDetails.SubscriptionId = SelectedSubscription.SubscriptionId;
cachedintegrationAccountDetails.ResourceGroupName = SelectedResourceGroup.Name;
cachedintegrationAccountDetails.IntegrationAccountName = SelectedIntegrationAccount.Name;
if (SelectedKeyVault != null)
{
cachedintegrationAccountDetails.KeyVaultName = SelectedKeyVault.Name;
}
}
this.ApplicationContext.SetProperty("Subscriptions", UserSubscriptions);
this.ApplicationContext.SetProperty("ResourceGroups", UserResourceGroups);
this.ApplicationContext.SetProperty("IntegrationAccounts", UserIntegrationAccounts);
this.ApplicationContext.SetProperty("KeyVaults", UserKeyVaults);
return(true);
}
public override async Task ExportToIA(SchemaMigrationItemViewModel serverSchemaItem, IntegrationAccountDetails iaDetails)
{
this.iaDetails = iaDetails;
try
{
TraceProvider.WriteLine("Migrating schema : {0}", serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload);
await Task.Factory.StartNew(() =>
{
try
{
AuthenticationResult authresult = thisApplicationContext.GetProperty("IntegrationAccountAuthorization") as AuthenticationResult;
bool overwrite = Convert.ToBoolean(thisApplicationContext.GetProperty("OverwriteEnabled"));
if (!overwrite)
{
bool exists = CheckIfArtifactExists(serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload, "Schema", this.iaDetails, authresult).Result;
if (exists)
{
serverSchemaItem.ExportStatus = MigrationStatus.Partial;
serverSchemaItem.ExportStatusText = string.Format("The Schema {0} already exists on IA with name {1}. Since the Overwrite option was disabled, the certificate was not overwritten.", serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload, FileOperations.GetFileName(serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload));
TraceProvider.WriteLine(serverSchemaItem.ExportStatusText);
TraceProvider.WriteLine();
}
else
{
MigrateToCloudIA(FileOperations.GetSchemaJsonFilePath(serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload), FileOperations.GetFileName(serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload), serverSchemaItem, iaDetails, authresult).Wait();
serverSchemaItem.ExportStatus = MigrationStatus.Succeeded;
serverSchemaItem.ExportStatusText = string.Format("Schema {0} migrated succesfully", serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload);
TraceProvider.WriteLine(string.Format("Schema Migration Successfull: {0}", serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload));
TraceProvider.WriteLine();
}
}
else
{
MigrateToCloudIA(FileOperations.GetSchemaJsonFilePath(serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload), FileOperations.GetFileName(serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload), serverSchemaItem, iaDetails, authresult).Wait();
serverSchemaItem.ExportStatus = MigrationStatus.Succeeded;
serverSchemaItem.ExportStatusText = string.Format("Schema {0} migrated succesfully", serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload);
TraceProvider.WriteLine(string.Format("Schema Migration Successfull: {0}", serverSchemaItem.MigrationEntity.fullNameOfSchemaToUpload));
TraceProvider.WriteLine();
}
}
catch (Exception)
{
//throw ex;
}
});
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <bool> CheckIfCertificateExists(string migrationItem, IntegrationAccountDetails iaDetails, AuthenticationResult authResult)
{
IntegrationAccountContext sclient = new IntegrationAccountContext();
HttpResponseMessage response = new HttpResponseMessage();
try
{
response = sclient.GetArtifactsFromIA(UrlHelper.GetCertificateUrl(migrationItem, iaDetails), authResult);
if (!response.IsSuccessStatusCode)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public async Task <HttpResponseMessage> MigrateToCloudIA(string filePath, string name, TEntity item, IntegrationAccountDetails iaDetails, AuthenticationResult authResult)
{
try
{
IntegrationAccountContext sclient = new IntegrationAccountContext();
var x = await sclient.LAIntegrationFromFile(UrlHelper.GetCertificateUrl(name, iaDetails), filePath, authResult);
return(x);
}
catch (Exception ex)
{
SetStatus(item, MigrationStatus.Failed, string.Format("Certificate Migration Failed. Reason:{0}", ExceptionHelper.GetExceptionMessage(ex)));
TraceProvider.WriteLine(string.Format("Certificate Migration Failed. Reason:{0}", ExceptionHelper.GetExceptionMessage(ex)));
TraceProvider.WriteLine();
throw ex;
}
}
public void CheckIfCertificateIsprivate(TEntity item, string certificateName, IntegrationAccountDetails iaDetails)
{
try
{
string filepath = FileOperations.GetCertificateJsonFilePath(certificateName);
string content = File.ReadAllText(filepath);
var certificate = JsonConvert.DeserializeObject <JsonCertificate.Rootobject>(content);
if (certificate.properties.key != null)
{
string keyvaultname = iaDetails.KeyVaultName;
if (string.IsNullOrEmpty(keyvaultname))
{
throw new Exception("Couldn't find the name of the Key Vault to upload the Private key for the Private Certificate. Make sure you selected a Key Vault at the Integration Account Details Screen");
}
string certName = FileOperations.GetFileName(certificateName);
string keyvaultfilepath = FileOperations.GetKeyVaultJsonFilePath(certName + "Privatekey");
IntegrationAccountContext sclient = new IntegrationAccountContext();
AuthenticationResult authresult = thisApplicationContext.GetProperty("KeyVaultAuthorization") as AuthenticationResult;
string kid = sclient.UploadCertificatePrivateKeyToKeyVault(StringOperations.RemoveAllSpecialCharacters(certName) + "Privatekey", keyvaultname, keyvaultfilepath, authresult);
certificate.properties.key.keyName = StringOperations.RemoveAllSpecialCharacters(certName) + "Privatekey";
certificate.properties.key.keyVersion = kid;
certificate.properties.key.keyVault.id = string.Format(ConfigurationManager.AppSettings["KeyVaultResourceIdTemplate"], iaDetails.SubscriptionId, iaDetails.ResourceGroupName, keyvaultname);
//certificate.properties.key.keyVault.name = certName + "Privatekey";
string fileName = FileOperations.GetCertificateJsonFilePath(certName);
string partnerJsonFileContent = JsonConvert.SerializeObject(certificate);
File.WriteAllText(fileName, partnerJsonFileContent);
}
}
catch (Exception ex)
{
SetStatus(item, MigrationStatus.Failed, string.Format("Certificate Migration Failed. Reason:{0}", ExceptionHelper.GetExceptionMessage(ex)));
TraceProvider.WriteLine(string.Format("Certificate Migration Failed. Reason:{0}", ExceptionHelper.GetExceptionMessage(ex)));
TraceProvider.WriteLine();
throw ex;
}
}
public async Task ExportToIA(TEntity item, IntegrationAccountDetails iaDetails)
{
this.iaDetails = iaDetails;
var serverPartnerItem = item as PartnerMigrationItemViewModel;
var certItem = item as Certificate;
string certName = string.Empty;
if (serverPartnerItem != null)
{
certName = serverPartnerItem.MigrationEntity.CertificateName;
}
else if (certItem != null)
{
certName = certItem.certificateName;
}
try
{
TraceProvider.WriteLine("Migrating certificate : {0}", certName);
await Task.Factory.StartNew(() =>
{
try
{
AuthenticationResult authresult = thisApplicationContext.GetProperty("IntegrationAccountAuthorization") as AuthenticationResult;
bool overwrite = Convert.ToBoolean(thisApplicationContext.GetProperty("OverwriteEnabled"));
if (!overwrite)
{
bool exists = CheckIfCertificateExists(certName, this.iaDetails, authresult).Result;
if (exists)
{
SetStatus(item, MigrationStatus.Partial, string.Format("The Certificate {0} already exists on IA with name {1}. Since the Overwrite option was disabled, the certificate was not overwritten.", certName, FileOperations.GetFileName(certName)));
TraceProvider.WriteLine(string.Format("The Certificate {0} already exists on IA with name {1}. Since the Overwrite option was disabled, the certificate was not overwritten.", certName, FileOperations.GetFileName(certName)));
TraceProvider.WriteLine();
}
else
{
CheckIfCertificateIsprivate(item, certName, iaDetails);
MigrateToCloudIA(FileOperations.GetCertificateJsonFilePath(certName), FileOperations.GetFileName(certName), item, iaDetails, authresult).Wait();
SetStatus(item, MigrationStatus.Succeeded, string.Format("Certificate {0} migrated succesfully", certName));
TraceProvider.WriteLine(string.Format("Certificate Migration Successfull: {0}", certName));
TraceProvider.WriteLine();
}
}
else
{
CheckIfCertificateIsprivate(item, certName, iaDetails);
MigrateToCloudIA(FileOperations.GetCertificateJsonFilePath(certName), FileOperations.GetFileName(certName), item, iaDetails, authresult).Wait();
SetStatus(item, MigrationStatus.Succeeded, string.Format("Certificate {0} migrated succesfully", certName));
TraceProvider.WriteLine(string.Format("Certificate Migration Successfull: {0}", certName));
TraceProvider.WriteLine();
}
}
catch (Exception)
{
//throw ex;
}
});
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <HttpResponseMessage> MigrateToCloudIAPartner(string filePath, string name, PartnerMigrationItemViewModel serverPartnerItem, IntegrationAccountDetails iaDetails, AuthenticationResult authResult)
{
try
{
IntegrationAccountContext sclient = new IntegrationAccountContext();
try
{
List <KeyValuePair <string, string> > partnerIdentities = new List <KeyValuePair <string, string> >();
var partnerInIA = sclient.GetArtifactsFromIA(UrlHelper.GetPartnerUrl(name, iaDetails), authResult);
string responseAsString = await partnerInIA.Content.ReadAsStringAsync();
JObject responseAsJObject = JsonConvert.DeserializeObject <JObject>(responseAsString);
var partner = responseAsJObject;
if (partner["properties"] != null && partner["properties"]["content"] != null && partner["properties"]["content"]["b2b"] != null && partner["properties"]["content"]["b2b"]["businessIdentities"] != null)
{
foreach (var identity in partner["properties"]["content"]["b2b"]["businessIdentities"])
{
if (identity["qualifier"] != null && identity["value"] != null)
{
KeyValuePair <string, string> kvpair = new KeyValuePair <string, string>(identity["qualifier"].ToString(), identity["value"].ToString());
if (!partnerIdentities.Contains(kvpair))
{
partnerIdentities.Add(kvpair);
}
}
}
}
var partnersFromLocalFile = File.ReadAllText(filePath);
var partnerContent = JsonConvert.DeserializeObject <JsonPartner.Rootobject>(partnersFromLocalFile);
var partnerIdentityDict = partnerContent.properties.content.b2b.businessIdentities.ToDictionary(xc => new KeyValuePair <string, string>(xc.qualifier, xc.value), xc => xc.value);
var partnerIdentityList = partnerContent.properties.content.b2b.businessIdentities.ToList();
foreach (var identity in partnerIdentities)
{
if (!partnerIdentityDict.ContainsKey(identity))
{
partnerIdentityDict.Add(identity, identity.Value);
partnerIdentityList.Add(new JsonPartner.Businessidentity {
qualifier = identity.Key, value = identity.Value
});
}
}
partnerContent.properties.content.b2b.businessIdentities = partnerIdentityList.ToArray();
var finalcontent = JsonConvert.SerializeObject(partnerContent);
File.WriteAllText(filePath, finalcontent);
}
catch (Exception)
{
//do nothing
}
var x = await sclient.LAIntegrationFromFile(UrlHelper.GetPartnerUrl(name, iaDetails), filePath, authResult);
return(x);
}
catch (Exception ex)
{
serverPartnerItem.ExportStatus = MigrationStatus.Failed;
serverPartnerItem.ExportStatusText = ex.Message;
TraceProvider.WriteLine(string.Format("Partner Migration Failed. Reason:{0}", ExceptionHelper.GetExceptionMessage(ex)));
TraceProvider.WriteLine();
throw ex;
}
}
public static string GeEdifactAgreementsUrl(IntegrationAccountDetails iaDetails)
{
string url = String.Format(ConfigurationManager.AppSettings["AgreementsUrl"], iaDetails.SubscriptionId, iaDetails.ResourceGroupName, iaDetails.IntegrationAccountName) + "&" + ConfigurationManager.AppSettings["EdifactAgreementsFilter"];
return(url);
}
public static string GetSchemasUrl(IntegrationAccountDetails iaDetails)
{
string url = String.Format(ConfigurationManager.AppSettings["SchemasUrl"], iaDetails.SubscriptionId, iaDetails.ResourceGroupName, iaDetails.IntegrationAccountName);
return(url);
}
public static string GetMapUrl(string mapname, IntegrationAccountDetails iaDetails)
{
string url = String.Format(ConfigurationManager.AppSettings["MapUrl"], iaDetails.SubscriptionId, iaDetails.ResourceGroupName, iaDetails.IntegrationAccountName, FileOperations.GetFileName(mapname));
return(url);
}
public async Task <HttpResponseMessage> MigrateToCloudIA(string filePath, string name, SchemaMigrationItemViewModel serverSchemaItem, IntegrationAccountDetails iaDetails, AuthenticationResult authResult)
{
try
{
IntegrationAccountContext sclient = new IntegrationAccountContext();
var x = await sclient.LAIntegrationFromFile(UrlHelper.GetSchemaUrl(name, iaDetails), filePath, authResult);
return(x);
}
catch (Exception ex)
{
serverSchemaItem.ExportStatus = MigrationStatus.Failed;
serverSchemaItem.ExportStatusText = ex.Message;
TraceProvider.WriteLine(string.Format("Schema Migration Failed. Reason:{0}", ExceptionHelper.GetExceptionMessage(ex)));
TraceProvider.WriteLine();
throw ex;
}
}
public async Task <bool> CheckIfArtifactExists(string migrationItem, string migrationEntity, IntegrationAccountDetails iaDetails, AuthenticationResult authResult)
{
IntegrationAccountContext sclient = new IntegrationAccountContext();
HttpResponseMessage response = new HttpResponseMessage();
try
{
if (migrationEntity == "Agreement")
{
response = sclient.GetArtifactsFromIA(UrlHelper.GetAgreementUrl(migrationItem, iaDetails), authResult);
}
if (migrationEntity == "Partner")
{
response = sclient.GetArtifactsFromIA(UrlHelper.GetPartnerUrl(migrationItem, iaDetails), authResult);
}
if (migrationEntity == "Certificate")
{
response = sclient.GetArtifactsFromIA(UrlHelper.GetCertificateUrl(migrationItem, iaDetails), authResult);
}
if (migrationEntity == "Schema")
{
response = sclient.GetArtifactsFromIA(UrlHelper.GetSchemaUrl(migrationItem, iaDetails), authResult);
}
if (migrationEntity == "Map")
{
response = sclient.GetArtifactsFromIA(UrlHelper.GetMapUrl(migrationItem, iaDetails), authResult);
}
if (!response.IsSuccessStatusCode)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public abstract Task ExportToIA(TMigrationItem migrationItem, IntegrationAccountDetails iaDetails);
