/// <summary>
/// Upload schema to IA
/// </summary>
/// <param name="authorizationKey"></param>
/// <param name="url">Rest URL</param>
/// <param name="fileLocation">Location from where the schema XSD is to be picked</param>
/// <param name="schemaName">name of the schema</param>
/// <returns></returns>
private HttpResponseMessage UploadMap(AuthenticationResult authResult, string url, string fileLocation, string mapName)
{
HttpResponseMessage response = null;
try
{
InitializeAuthorizationCredentials();
}
catch (Exception ex)
{
throw ex;
}
try
{
response = UploadToIA(authResult, url, fileLocation, mapName);
return(response);
}
catch (Exception ex)
{
try
{
authResult = RefreshAccessToken(authResult.UserInfo, AuthenticationAccessToken.IntegrationAccount);
response = UploadToIA(authResult, url, fileLocation, mapName);
return(response);
}
catch (Exception e)
{
string message = $"ERROR! Exception while putting map {mapName} to Integration Account. \nErrorMessage: {e.Message}";
TraceProvider.WriteLine($"{message} \nStackTrace:{e.StackTrace}");
throw new Exception(message);
}
}
}
/// <summary>
/// Call to start the process of upload to integration account
/// </summary>
/// <param name="mapsToBeUploaded"></param>
/// <param name="mapsDetailsList"></param>
/// <param name="outputDir"></param>
/// <param name="overrideExistingMapsFlag"></param>
/// <param name="aadInstance"></param>
/// <param name="resource"></param>
/// <param name="clientId"></param>
/// <param name="clientSecret"></param>
/// <param name="subscriptionId"></param>
/// <param name="resourceGroupName"></param>
/// <param name="iaName"></param>
public void UploadToIntegrationAccount(List <MapDetails> mapsToBeUploaded, ref List <MapDetails> mapDetailsList, string outputDir, bool overrideExistingMapsFlag, string subscriptionId, string resourceGroupName, string iaName, AuthenticationResult authResult)
{
if (mapsToBeUploaded.Count > 0)
{
IntegrationAccountContextForMaps iacontext = new IntegrationAccountContextForMaps();
try
{
IntegrationAccountDetails iaDetails = new IntegrationAccountDetails
{
SubscriptionId = subscriptionId,
ResourceGroupName = resourceGroupName,
IntegrationAccountName = iaName
};
iacontext.SchemaUploadFromFolder(outputDir, mapsToBeUploaded, overrideExistingMapsFlag, iaDetails, authResult, ref mapDetailsList);
}
catch (Exception e)
{
string message = $"ERROR! Something went wrong while doing a map upload from local folder ${outputDir}. \nErrorMessage:{e.Message}";
TraceProvider.WriteLine($"{message} \nStackTrace:{e.StackTrace}");
throw e;
}
}
}
/// <summary>
/// To extract selected maps from all the maps which we had retrieved by reflecting upon the DLLs
/// </summary>
/// <param name="selectiveMapDetailsList"></param>
/// <param name="outputDir"></param>
/// <param name="originalMapDetailsList"></param>
/// <returns>Returns the order of the maps to be uploaded to IA</returns>
public List <MapDetails> ExtractMapsFromDlls(ref List <MapDetails> selectiveMapDetailsList, string outputDir, List <MapDetails> originalMapDetailsList)
{
this.originalMapDetailsList = originalMapDetailsList;
// Location where the all the retrieved maps are stored upon reflection of GAC'ed DLLs
var d = new DirectoryInfo(outputDir + "\\AllMaps");
var filesInfo = d.GetFiles("*.xslt");
if (filesInfo.Length == 0)
{
string message = $"ERROR! No maps got extracted from the assembly into the local.";
TraceProvider.WriteLine(message);
//Console.WriteLine(message);
throw new Exception(message);
}
// loop thru all the maps selected via the UI for extraction and enable their extraction flag on successful extraction
foreach (var selectedMap in selectiveMapDetailsList)
{
try
{
if (selectedMap.fullNameOfMapToUpload != null)
{
selectedMap.isMapExtractedFromDb = true;
TraceProvider.WriteLine($"Selected map extracted successfully: {selectedMap.fullNameOfMapToUpload}");
}
else
{
selectedMap.isMapExtractedFromDb = false;
selectedMap.errorDetailsForExtraction = selectedMap.errorDetailsForExtraction + " " + "ERROR! DLL to which this map belongs is not GAC'ed on your machine. Please GAC this required DLL (as warned in the Log File).";
}
}
catch (Exception ex)
{
string message = $"ERROR! Problem during extracttion of selected maps. \nErrorMessage:{ex.Message}";
TraceProvider.WriteLine($"{message} \nStackTrace:{ex.StackTrace}");
//Console.WriteLine($"{message} \nStackTrace:{ex.StackTrace}");
selectedMap.errorDetailsForExtraction = selectedMap.errorDetailsForExtraction + "\n" + message;
//throw new Exception(message);
}
}
// the dictionary of the schemas and all their dependencies are now with us, pass on this dictionary to below code to get the order of upload to IA
var mapsToBeUploaded = new List <MapDetails>();
foreach (var item in selectiveMapDetailsList)
{
string source = outputDir + "AllMaps\\" + item.fullNameOfMapToUpload + ".xslt";
string dest = outputDir + item.fullNameOfMapToUpload + ".xslt";
File.Copy(source, dest);
mapsToBeUploaded.Add(item);
}
return(mapsToBeUploaded);
}
/// <summary>
/// Clear the directory for a new selection
/// </summary>
/// <param name="outputdir"></param>
private void SetMapAndDllDirectories(string outputdir)
{
try
{
if (ConfigurationManager.AppSettings["mapOutputDir"].ToString() != "")
{
mapOutputDir = ConfigurationManager.AppSettings["mapOutputDir"].ToString();
}
else
{
mapOutputDir = outputdir;
}
}
catch (Exception)
{
mapOutputDir = outputdir;
}
TraceProvider.WriteLine($"Map Output Directory is {mapOutputDir} ");
if (Directory.Exists(mapOutputDir))
{
DeleteDirectory(mapOutputDir);
}
try
{
if (ConfigurationManager.AppSettings["dllLocation"].ToString() != "")
{
dllLocation = ConfigurationManager.AppSettings["dllLocation"].ToString();
TraceProvider.WriteLine("DLLs are at location " + dllLocation);
}
else
{
TraceProvider.WriteLine("The configured DLL Directory Location is Empty. Assuming DLLs are to be read from the GAC");
//Console.WriteLine("The configured DLL Directory Location is Empty. Assuming DLLs are to be read from the GAC");
}
}
catch (Exception)
{
TraceProvider.WriteLine("No DLL Directory Location Configured. Assuming DLLs are to be read from the GAC");
//Console.WriteLine("No DLL Directory Location Configured. Assuming DLLs are to be read from the GAC");
}
}
/// <summary>
/// Starting point for upload of map
/// </summary>
/// <param name="fileLocation">Location where map XSLXs are picked from after their extraction</param>
/// <param name="schemaList">List of maps to be uploaded</param>
/// <param name="overrideExistingMapsFlag">Flag about whether to override the existing maps in the IA</param>
/// <param name="iaDetails">IA auth details</param>
/// <param name="mapDetailsList">List of schemas to be uploaded</param>
public void SchemaUploadFromFolder(string fileLocation, List <MapDetails> mapList, bool overrideExistingMapsFlag, IntegrationAccountDetails iaDetails, AuthenticationResult authResult, ref List <MapDetails> mapDetailsList)
{
TraceProvider.WriteLine("Extraction of maps. Starting upload to Integration Account...");
try
{
// AAD Authentication - Getting of Token
if (string.IsNullOrEmpty(authResult.AccessToken))
{
string message = $"ERROR! Problem during AAD authentication. \nErrorMessage: Invalid access token";
TraceProvider.WriteLine($"{message}");
//Console.WriteLine($"{message} \nStackTrace:{e.StackTrace}");
throw new Exception(message);
}
}
catch (Exception ex)
{
throw ex;
}
// Do one by one upload on each schema XSD based on flags - whether to override, whether schema already exists, whether schema got successfully extracted
foreach (var mapName in mapList)
{
var url = ConfigurationManager.AppSettings["MapRestUrl"];
var response = new HttpResponseMessage();
try
{
url = string.Format(url, iaDetails.SubscriptionId, iaDetails.ResourceGroupName, iaDetails.IntegrationAccountName, mapName.fullNameOfMapToUpload);
bool exists = CheckIfArtifactExists(url, authResult);
if (overrideExistingMapsFlag)
{
if (mapName.isMapExtractedFromDb == false)
{
TraceProvider.WriteLine("Uploading unselected dependency. Schema:" + mapName.fullNameOfMapToUpload);
// Console.WriteLine("Uploading unselected dependency. Schema:" + schemaName.fullNameOfSchemaToUpload);
}
else
{
TraceProvider.WriteLine($"Uploading map {mapName.fullNameOfMapToUpload}");
//Console.WriteLine($"Uploading schema {schemaName.fullNameOfSchemaToUpload}");
}
response = UploadMap(authResult, url, fileLocation, mapName.fullNameOfMapToUpload);
}
else if (exists)
{
response.StatusCode = System.Net.HttpStatusCode.Conflict;
if (mapName.isMapExtractedFromDb == false)
{
TraceProvider.WriteLine($"Unselected dependent schema {mapName.fullNameOfMapToUpload} already exists");
}
else
{
TraceProvider.WriteLine($"Schema {mapName.fullNameOfMapToUpload} already exists");
}
}
else
{
if (mapName.isMapExtractedFromDb == false)
{
TraceProvider.WriteLine($"Uploading unselected dependency. Map:{mapName.fullNameOfMapToUpload}");
}
else
{
TraceProvider.WriteLine($"Uploading map {mapName}");
}
response = UploadMap(authResult, url, fileLocation, mapName.fullNameOfMapToUpload);
}
// response status code for a particular map after upload rest operation has been performed on it
if (response.StatusCode == System.Net.HttpStatusCode.Conflict)
{
if (mapName.isMapExtractedFromDb)
{
string message = $"Conflict for map {mapName.fullNameOfMapToUpload}. Response:{response.StatusCode}";
mapName.mapUploadToIAStatus = MapUploadToIAStatus.Partial;
mapName.errorDetailsForMigration = mapName.errorDetailsForMigration + ". " + message + ". Check logs for details.";
TraceProvider.WriteLine(message);
//Console.WriteLine(message);
}
else
{
TraceProvider.WriteLine($"Conflict for unselected dependency map {mapName.fullNameOfMapToUpload}. Response:{response.StatusCode}");
}
}
else if (!response.IsSuccessStatusCode)
{
if (mapName.isMapExtractedFromDb)
{
string message = $"Failed for map {mapName.fullNameOfMapToUpload}. ResponseStatusCode:{response}";
mapName.mapUploadToIAStatus = MapUploadToIAStatus.Failure;
mapName.errorDetailsForMigration = mapName.errorDetailsForMigration + ". " + message + ". Check logs for details.";
TraceProvider.WriteLine(message);
//Console.WriteLine(message);
}
else
{
TraceProvider.WriteLine($"Failed for hidden dependency map {mapName.fullNameOfMapToUpload}. Response:{response}");
}
}
else
{
if (mapName.isMapExtractedFromDb)
{
mapName.mapUploadToIAStatus = MapUploadToIAStatus.Success;
TraceProvider.WriteLine($"Successfully uploaded map {mapName.fullNameOfMapToUpload} to Integration Account. Response:{response.StatusCode}");
}
else
{
TraceProvider.WriteLine($"Successfully uploaded unselected dependent map {mapName.fullNameOfMapToUpload} to Integration Account. Response: {response.StatusCode}");
}
}
}
catch (Exception ex)
{
string message = $"Failed to upload map {mapName.fullNameOfMapToUpload}. IA Rest API returned a response {response}. \nErrorMessage:{ex.Message}";
TraceProvider.WriteLine($"{message} \nStackTrace:{ex.StackTrace}");
//Console.WriteLine($"{message} \nStackTrace:{ex.StackTrace}");
mapName.mapUploadToIAStatus = MapUploadToIAStatus.Failure;
mapName.errorDetailsForMigration = mapName.errorDetailsForMigration + ". " + message + ". Check logs for details.";
}
}
}
/// <summary>
/// Function to get the list of maps
/// </summary>
/// <param name="sqlConnectionString"></param>
/// <param name="outputDir"></param>
/// <returns></returns>
public List <MapDetails> GetListOfMaps(string sqlConnectionString, string outputDir, string parameter)
{
SetMapAndDllDirectories(outputDir);
var mapDetailsObj = new MapDetails();
var originalMapDetailsObj = new MapDetails();
using (SqlConnection cn = new SqlConnection(sqlConnectionString))
{
var query = ConfigurationManager.AppSettings["MapQueryApplication"];
query = string.Format(query, parameter);
//or nvcFullName like 'MSIT.EAS.ICOE.VL.PosOrdrsp.Shared.Schemas.AP%'
//or nvcFullName like 'MSIT.EAS.ICOE.VL.ZInvoic.Shared.Schemas.AP%'
//or nvcFullName like 'MSIT.EAS.ICOE.VL.PropertySchemas%')
//and nvcFullName like 'MSIT.EAS.ICOE.VL.Ordrsp.Shared.Schemas.AP%'";
using (var cmd = new SqlCommand(query, cn))
{
if (cn.State == System.Data.ConnectionState.Closed)
{
try { cn.Open(); }
catch (Exception e)
{
string message = $"ERROR! Unable to establish connection to the database. \nErrorMessage:{e.Message}";
TraceProvider.WriteLine($"{message} \nStackTrace:{e.StackTrace}");
//Console.WriteLine($"{message} \nStackTrace:{e.StackTrace}");
throw new Exception(message);
}
}
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
mapDetailsObj = new MapDetails();
originalMapDetailsObj = new MapDetails();
mapDetailsObj.assemblyFullyQualifiedName = rdr["nvcFullName"].ToString();
originalMapDetailsObj.assemblyFullyQualifiedName = rdr["nvcFullName"].ToString();
mapDetailsObj.mapUploadToIAStatus = MapUploadToIAStatus.NotYetStarted;
mapDetailsObj.errorDetailsForMigration = "";
mapDetailsObj.errorDetailsForExtraction = "";
mapDetailsObj.mapFilesLocation = outputDir;
mapDetailsObj.mapFullName = rdr["FullName"].ToString();
originalMapDetailsObj.mapFullName = rdr["FullName"].ToString();
mapDetailsObj.mapName = rdr["Name"].ToString();
originalMapDetailsObj.mapName = rdr["Name"].ToString();
mapDetailsObj.mapNamespace = rdr["Namespace"].ToString();
mapDetailsObj.version = rdr["nvcVersion"].ToString();
mapDetailsList.Add(mapDetailsObj);
originalMapDetailsList.Add(originalMapDetailsObj);
}
}
}
}
Directory.CreateDirectory(mapOutputDir);
Directory.CreateDirectory(mapOutputDir + "\\AllMaps");
PutAllMapsToLocalFolder(ref mapDetailsList, outputDir);
return(mapDetailsList);
}
/// <summary>
/// Putting all maps to a local folder
/// </summary>
/// <param name="mapDetailsList"></param>
/// <param name="outputDir"></param>
public void PutAllMapsToLocalFolder(ref List <MapDetails> mapDetailsList, string outputDir)
{
var distinctAssembliesList = new HashSet <string>();
foreach (var mapObj in mapDetailsList)
{
distinctAssembliesList.Add(mapObj.assemblyFullyQualifiedName);
}
try
{
foreach (var fqnForAssembly in distinctAssembliesList)
{
var dllName = Path.GetFileName(fqnForAssembly).Replace(".dll", string.Empty).Replace('.', '_').Substring(0, Path.GetFileName(fqnForAssembly).IndexOf(','));
dllName = dllName + "_V" + fqnForAssembly.Substring(fqnForAssembly.IndexOf("Version"), 15).Replace(".", "_").Replace("Version=", "");
//Load the assembly into memory
Assembly asm;
try
{
asm = Assembly.Load(fqnForAssembly);
}
catch (FileNotFoundException e)
{
TraceProvider.WriteLine($"WARNING! Assembly with name {fqnForAssembly} to which identified Schemas belong is not found in GAC'ed DLLs. Message:{e.Message}");
//Console.WriteLine($"WARNING! Assembly with name {fqnForAssembly} to which identified Schemas belong is not found in GAC'ed DLLs. Message:{e.Message}");
continue;
}
var mapObj = new MapDetails();
var originalMapObj = new MapDetails();
var types = asm.GetTypes();
var classTypes = types.Where(type => type.IsClass == true && (type.BaseType.Name == "TransformBase") || (type.BaseType.BaseType != null && type.BaseType.BaseType.Name == "TransformBase"));
foreach (Type ty in types)
{
try
{
mapObj = mapDetailsList.First <MapDetails>(r => r.mapName == ty.Name && r.assemblyFullyQualifiedName == ty.Assembly.FullName);
originalMapObj = originalMapDetailsList.First <MapDetails>(r => r.mapName == ty.Name && r.assemblyFullyQualifiedName == ty.Assembly.FullName);
}
catch (Exception e)
{
continue;
}
try
{
//// for every new schema in the DLL
//if (ty.BaseType != null && ty.BaseType.FullName == "Microsoft.XLANGs.BaseTypes.SchemaBase")
//{
// var sb = System.Activator.CreateInstance(ty) as SchemaBase;
// var schemaFileName = ty.Name;
// if (ty.DeclaringType == null)
// {
// var schemaXmlContext = sb.XmlContent;
// schemaXmlContext = schemaXmlContext.Replace("utf-16", "utf-8");
// Match matchVersion = Regex.Match(schemaXmlContext, "standards_version=\"(.*?)\"");
// Match matchNamespace = Regex.Match(schemaXmlContext, "targetNamespace=\"(.*?)\"");
// if (matchVersion.Success && matchNamespace.Success)
// {
// if (!schemaNamespaceVersionDict.ContainsKey(matchNamespace.Groups[1].Value))
// {
// schemaNamespaceVersionDict.Add(matchNamespace.Groups[1].Value, matchVersion.Groups[1].Value);
// }
// }
// schemaFileName = dllName + "_" + schemaFileName;
// // truncate the length of the schema if its more than what the IA can handle
// if (schemaFileName.Length > 79)
// schemaFileName = schemaFileName.Replace("_", "");
// schemaObj.fullNameOfSchemaToUpload = schemaFileName;
// originalSchemaObj.fullNameOfSchemaToUpload = schemaFileName;
// // Write to file
// var schemaFilePath = string.Format(outputDir + "\\AllSchemas\\{0}.xsd", schemaFileName);
// File.WriteAllText(schemaFilePath, schemaXmlContext, Encoding.UTF8);
// }
//}
object mapObject = Activator.CreateInstance(ty);
object map = ty.InvokeMember("XmlContent", BindingFlags.GetProperty, null, mapObject, null);
string mapstr = map.ToString();
Match matchVersion = Regex.Match(mapstr, "standards_version=\"(.*?)\"");
Match matchNamespace = Regex.Match(mapstr, "targetNamespace=\"(.*?)\"");
if (matchVersion.Success && matchNamespace.Success)
{
if (!mapNamespaceVersionDict.ContainsKey(matchNamespace.Groups[1].Value))
{
mapNamespaceVersionDict.Add(matchNamespace.Groups[1].Value, matchVersion.Groups[1].Value);
}
}
var mapFileName = ty.Name;
mapFileName = dllName + "_" + mapFileName;
// truncate the length of the schema if its more than what the IA can handle
if (mapFileName.Length > 79)
{
mapFileName = mapFileName.Replace("_", "");
}
mapObj.fullNameOfMapToUpload = mapFileName;
originalMapObj.fullNameOfMapToUpload = mapFileName;
// Write to file
var mapFilePath = string.Format(outputDir + "\\AllMaps\\{0}.xslt", mapFileName);
File.WriteAllText(mapFilePath, mapstr, Encoding.UTF8);
}
catch (Exception e)
{
string message = $"ERROR! Problem reading schema content from MapBase and Writing the file to Local Folder. \nMap:{mapObj.mapFullName} \nAssembly:{mapObj.assemblyFullyQualifiedName} \nErrorMessage: {e.Message}";
TraceProvider.WriteLine($"{message} \nStackTrace:{e.StackTrace}");
throw new Exception(message);
}
}
}
}
catch (Exception e)
{
string message = $"ERROR! Something went wrong. \nErrorMessage:{e.Message}";
TraceProvider.WriteLine($"{message} \nStackTrace:{e.StackTrace}");
//Console.WriteLine($"{message} \nStackTrace:{e.StackTrace}");
throw new Exception(message);
}
}