private string CreateFile(ConnectionData connectionData, string folder, string solutionName, DateTime?createdOn, string fieldTitle, string xmlContent)
{
string fileName = EntityFileNameFormatter.GetImportJobFileName(connectionData.Name, solutionName, createdOn, fieldTitle, FileExtension.xml);
string filePath = Path.Combine(folder, FileOperations.RemoveWrongSymbols(fileName));
string createdOnString = createdOn?.ToString(EntityFileNameFormatter.dateFormatYearMonthDayHourMinuteSecond);
string name = string.Format("{0} at {1}", solutionName, createdOnString);
if (!string.IsNullOrEmpty(xmlContent))
{
try
{
xmlContent = ContentComparerHelper.FormatXmlByConfiguration(xmlContent, _commonConfig, XmlOptionsControls.ImportJobXmlOptions);
File.WriteAllText(filePath, xmlContent, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.InConnectionEntityFieldExportedToFormat5, connectionData.Name, ImportJob.Schema.EntityLogicalName, name, fieldTitle, filePath);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(connectionData, ex);
}
}
else
{
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, connectionData.Name, ImportJob.Schema.EntityLogicalName, name, fieldTitle);
this._iWriteToOutput.ActivateOutputWindow(connectionData);
}
return(filePath);
}
private Translation GetFieldTranslations()
{
Translation result = null;
try
{
var request = new ExportFieldTranslationRequest();
var response = (ExportFieldTranslationResponse)_service.Execute(request);
var traslationZipFile = response.ExportTranslationFile;
var traslationFileBytes = FileOperations.UnzipCrmTranslations(traslationZipFile, "/CrmFieldTranslations.xml");
string xml = Encoding.UTF8.GetString(traslationFileBytes);
xml = ContentComparerHelper.RemoveDiacritics(xml);
result = new Translation();
XElement doc = XElement.Parse(xml);
FillTranslation(result, doc);
}
catch (Exception ex)
{
Helpers.DTEHelper.WriteExceptionToOutput(_service.ConnectionData, ex);
}
return(result);
}
protected override void CommandAction(DTEHelper helper)
{
EnvDTE.Document document = helper.GetOpenedDocumentInCodeWindow(FileOperations.SupportsXmlType);
if (document == null)
{
return;
}
var objTextDoc = document.Object(nameof(EnvDTE.TextDocument));
if (objTextDoc != null && objTextDoc is EnvDTE.TextDocument textDocument)
{
string text = textDocument.StartPoint.CreateEditPoint().GetText(textDocument.EndPoint);
if (!string.IsNullOrEmpty(text))
{
if (ContentComparerHelper.TryParseXmlDocument(text, out var doc))
{
string docRootName = doc.Root.Name.ToString();
var schemasResources = AbstractDynamicCommandXsdSchemas.GetXsdSchemasByRootName(docRootName);
if (schemasResources != null)
{
ContentComparerHelper.ReplaceXsdSchemaInDocument(document, schemasResources);
}
}
}
}
}
private void GetCurrentSystemFormJson(IOrganizationServiceExtented service, CommonConfiguration commonConfig, SystemForm systemForm)
{
string formJson = systemForm.FormJson;
if (string.IsNullOrEmpty(formJson))
{
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, service.ConnectionData.Name, SystemForm.Schema.EntityLogicalName, systemForm.Name, SystemForm.Schema.Headers.formjson);
this._iWriteToOutput.ActivateOutputWindow(service.ConnectionData);
return;
}
formJson = ContentComparerHelper.FormatJson(formJson);
commonConfig.CheckFolderForExportExists(this._iWriteToOutput);
string currentFileName = EntityFileNameFormatter.GetSystemFormFileName(service.ConnectionData.Name, systemForm.ObjectTypeCode, systemForm.Name, SystemForm.Schema.Headers.formjson, FileExtension.json);
string currentFilePath = Path.Combine(commonConfig.FolderForExport, FileOperations.RemoveWrongSymbols(currentFileName));
try
{
File.WriteAllText(currentFilePath, formJson, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionEntityFieldExportedToFormat5, service.ConnectionData.Name, SystemForm.Schema.EntityLogicalName, systemForm.Name, SystemForm.Schema.Headers.formjson, currentFilePath);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(service.ConnectionData, ex);
}
this._iWriteToOutput.PerformAction(service.ConnectionData, currentFilePath);
service.TryDispose();
}
private string CreateFile(ConnectionData connectionData, string name, Guid id, string fieldTitle, string xmlContent)
{
string fileName = EntityFileNameFormatter.GetReportFileName(connectionData.Name, name, id, fieldTitle, FileExtension.xml);
string filePath = Path.Combine(_commonConfig.FolderForExport, FileOperations.RemoveWrongSymbols(fileName));
if (!string.IsNullOrEmpty(xmlContent))
{
try
{
if (ContentComparerHelper.TryParseXml(xmlContent, out var doc))
{
xmlContent = doc.ToString();
}
File.WriteAllText(filePath, xmlContent, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.InConnectionEntityFieldExportedToFormat5, connectionData.Name, Report.Schema.EntityLogicalName, name, fieldTitle, filePath);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(connectionData, ex);
}
}
else
{
filePath = string.Empty;
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, connectionData.Name, Report.Schema.EntityLogicalName, name, fieldTitle);
}
return(filePath);
}
private string CreateFile(ConnectionData connectionData, string name, string nameUnique, Guid id, string fieldTitle, string siteMapXml)
{
string fileName = EntityFileNameFormatter.GetSiteMapFileName(connectionData.Name, name, id, fieldTitle, FileExtension.xml);
string filePath = Path.Combine(_commonConfig.FolderForExport, FileOperations.RemoveWrongSymbols(fileName));
if (!string.IsNullOrEmpty(siteMapXml))
{
try
{
siteMapXml = ContentComparerHelper.FormatXmlByConfiguration(
siteMapXml
, _commonConfig
, XmlOptionsControls.SiteMapXmlOptions
, schemaName: AbstractDynamicCommandXsdSchemas.SiteMapXmlSchema
, siteMapUniqueName: nameUnique ?? string.Empty
);
File.WriteAllText(filePath, siteMapXml, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.InConnectionEntityFieldExportedToFormat5, connectionData.Name, SiteMap.Schema.EntityLogicalName, name, fieldTitle, filePath);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(connectionData, ex);
}
}
else
{
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, connectionData.Name, SiteMap.Schema.EntityLogicalName, name, fieldTitle);
this._iWriteToOutput.ActivateOutputWindow(connectionData);
}
return(filePath);
}
private async Task <bool> ValidateDocumentSavedQueryXml(ConnectionData connectionData, XDocument doc)
{
string fieldName = SavedQueryRepository.GetFieldNameByXmlRoot(doc.Root.Name.ToString());
string fieldTitle = SavedQueryRepository.GetFieldTitleByXmlRoot(doc.Root.Name.ToString());
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.ValidatingXmlForFieldFormat1, fieldTitle);
ContentComparerHelper.ClearRoot(doc);
bool validateResult = await SavedQueryRepository.ValidateXmlDocumentAsync(connectionData, _iWriteToOutput, doc, fieldTitle);
if (!validateResult)
{
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.ValidatingXmlForFieldFailedFormat1, fieldTitle);
_iWriteToOutput.ActivateOutputWindow(connectionData);
var dialogResult = MessageBoxResult.Cancel;
var thread = new Thread(() =>
{
dialogResult = MessageBox.Show(Properties.MessageBoxStrings.ContinueOperation, Properties.MessageBoxStrings.QuestionTitle, MessageBoxButton.OKCancel, MessageBoxImage.Question);
});
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
thread.Join();
if (dialogResult != MessageBoxResult.OK)
{
return(false);
}
}
return(true);
}
private string CreateFile(ConnectionData connectionData, string entityName, string name, string fieldTitle, string xmlContent)
{
string fileName = EntityFileNameFormatter.GetSavedQueryVisualizationFileName(connectionData.Name, entityName, name, fieldTitle, FileExtension.xml);
string filePath = Path.Combine(_commonConfig.FolderForExport, FileOperations.RemoveWrongSymbols(fileName));
if (!string.IsNullOrEmpty(xmlContent))
{
try
{
xmlContent = ContentComparerHelper.FormatXmlByConfiguration(
xmlContent
, _commonConfig
, XmlOptionsControls.SavedQueryVisualizationXmlOptions
, schemaName: AbstractDynamicCommandXsdSchemas.VisualizationDataDescriptionSchema
);
File.WriteAllText(filePath, xmlContent, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.InConnectionEntityFieldExportedToFormat5, connectionData.Name, SavedQueryVisualization.Schema.EntityLogicalName, name, fieldTitle, filePath);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(connectionData, ex);
}
}
else
{
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, connectionData.Name, SavedQueryVisualization.Schema.EntityLogicalName, name, fieldTitle);
this._iWriteToOutput.ActivateOutputWindow(connectionData);
}
return(filePath);
}
private async Task <bool> ValidateDocumentWebResourceDependencyXml(ConnectionData connectionData, XDocument doc)
{
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.ValidatingXmlForFieldFormat1, WebResource.Schema.Attributes.dependencyxml);
ContentComparerHelper.ClearRoot(doc);
bool validateResult = await WebResourceRepository.ValidateXmlDocumentAsync(connectionData, _iWriteToOutput, doc);
if (!validateResult)
{
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.ValidatingXmlForFieldFailedFormat1, WebResource.Schema.Attributes.dependencyxml);
_iWriteToOutput.ActivateOutputWindow(connectionData);
var dialogResult = MessageBoxResult.Cancel;
var thread = new Thread(() =>
{
dialogResult = MessageBox.Show(Properties.MessageBoxStrings.ContinueOperation, Properties.MessageBoxStrings.QuestionTitle, MessageBoxButton.OKCancel, MessageBoxImage.Question);
});
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
thread.Join();
if (dialogResult != MessageBoxResult.OK)
{
return(false);
}
}
return(true);
}
protected override void CommandAction(DTEHelper helper, Tuple <ConnectionData, ConnectionData> connectionDataPair)
{
List <SelectedFile> selectedFiles = helper.GetOpenedFileInCodeWindow(FileOperations.SupportsXmlType).Take(2).ToList();
if (selectedFiles.Count == 1)
{
string fileText = File.ReadAllText(selectedFiles[0].FilePath);
if (ContentComparerHelper.TryParseXml(fileText, out var doc))
{
var attribute = doc.Attribute(Intellisense.Model.IntellisenseContext.IntellisenseContextAttributeEntityName);
string entityName = attribute?.Value;
if (!string.IsNullOrEmpty(entityName))
{
helper.HandleOpenEntityMetadataOrganizationComparerCommand(connectionDataPair.Item1, connectionDataPair.Item2, entityName);
}
else
{
helper.HandleOpenApplicationRibbonOrganizationComparerCommand(connectionDataPair.Item1, connectionDataPair.Item2);
}
}
}
}
private async Task UpdateWebResourceDependencyXml(IOrganizationServiceExtented service, CommonConfiguration commonConfig, XDocument doc, string filePath, WebResource webResource)
{
{
string fieldTitle = WebResource.Schema.Headers.dependencyxml;
string dependencyXml = webResource.DependencyXml;
if (!string.IsNullOrEmpty(dependencyXml))
{
commonConfig.CheckFolderForExportExists(this._iWriteToOutput);
string fileNameBackUp = EntityFileNameFormatter.GetWebResourceFileName(service.ConnectionData.Name, webResource.Name, fieldTitle + " BackUp", FileExtension.xml);
string filePathBackUp = Path.Combine(commonConfig.FolderForExport, FileOperations.RemoveWrongSymbols(fileNameBackUp));
try
{
dependencyXml = ContentComparerHelper.FormatXmlByConfiguration(
dependencyXml
, commonConfig
, XmlOptionsControls.WebResourceDependencyXmlOptions
, schemaName: AbstractDynamicCommandXsdSchemas.WebResourceDependencyXmlSchema
, webResourceName: webResource.Name
);
File.WriteAllText(filePathBackUp, dependencyXml, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionEntityFieldExportedToFormat5, service.ConnectionData.Name, WebResource.Schema.EntityLogicalName, webResource.Name, fieldTitle, filePathBackUp);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(service.ConnectionData, ex);
}
}
else
{
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, service.ConnectionData.Name, WebResource.Schema.EntityLogicalName, webResource.Name, fieldTitle);
this._iWriteToOutput.ActivateOutputWindow(service.ConnectionData);
}
}
var newText = doc.ToString(SaveOptions.DisableFormatting);
var updateEntity = new WebResource
{
Id = webResource.Id
};
updateEntity.Attributes[WebResource.Schema.Attributes.dependencyxml] = newText;
await service.UpdateAsync(updateEntity);
var repositoryPublish = new PublishActionsRepository(service);
_iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionPublishingWebResourceFormat2, service.ConnectionData.Name, webResource.Name);
await repositoryPublish.PublishWebResourcesAsync(new[] { webResource.Id });
service.TryDispose();
}
private async Task UpdateSiteMapXml(IOrganizationServiceExtented service, CommonConfiguration commonConfig, XDocument doc, string filePath, SiteMap siteMap)
{
string fieldTitle = SiteMap.Schema.Headers.sitemapxml;
{
string siteMapXml = siteMap.SiteMapXml;
if (!string.IsNullOrEmpty(siteMapXml))
{
commonConfig.CheckFolderForExportExists(this._iWriteToOutput);
string fileNameBackUp = EntityFileNameFormatter.GetSiteMapFileName(service.ConnectionData.Name, siteMap.SiteMapNameUnique, siteMap.Id, fieldTitle + " BackUp", FileExtension.xml);
string filePathBackUp = Path.Combine(commonConfig.FolderForExport, FileOperations.RemoveWrongSymbols(fileNameBackUp));
try
{
siteMapXml = ContentComparerHelper.FormatXmlByConfiguration(
siteMapXml
, commonConfig
, XmlOptionsControls.SiteMapXmlOptions
, schemaName: AbstractDynamicCommandXsdSchemas.SiteMapXmlSchema
, siteMapUniqueName: siteMap.SiteMapNameUnique ?? string.Empty
);
File.WriteAllText(filePathBackUp, siteMapXml, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionEntityFieldExportedToFormat5, service.ConnectionData.Name, SiteMap.Schema.EntityLogicalName, siteMap.SiteMapNameUnique, fieldTitle, filePathBackUp);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(service.ConnectionData, ex);
}
}
else
{
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, service.ConnectionData.Name, SiteMap.Schema.EntityLogicalName, siteMap.SiteMapNameUnique, fieldTitle);
this._iWriteToOutput.ActivateOutputWindow(service.ConnectionData);
}
}
var newText = doc.ToString(SaveOptions.DisableFormatting);
var updateEntity = new SiteMap
{
Id = siteMap.Id
};
updateEntity.Attributes[SiteMap.Schema.Attributes.sitemapxml] = newText;
await service.UpdateAsync(updateEntity);
_iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionPublishingSiteMapFormat3, service.ConnectionData.Name, siteMap.SiteMapName, siteMap.Id.ToString());
var repositoryPublish = new PublishActionsRepository(service);
await repositoryPublish.PublishSiteMapsAsync(new[] { siteMap.Id });
service.TryDispose();
}
protected override void CommandAction(DTEHelper helper)
{
var document = helper.GetOpenedDocumentInCodeWindow(FileOperations.SupportsXmlType);
if (document != null)
{
var objTextDoc = document.Object(nameof(EnvDTE.TextDocument));
if (objTextDoc != null &&
objTextDoc is EnvDTE.TextDocument textDocument
)
{
string text = textDocument.StartPoint.CreateEditPoint().GetText(textDocument.EndPoint);
if (!string.IsNullOrEmpty(text))
{
if (ContentComparerHelper.TryParseXmlDocument(text, out var doc))
{
string docRootName = doc.Root.Name.ToString();
if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.SiteMapXmlRoot, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleSiteMapDifferenceCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RibbonDiffXmlRoot, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleRibbonDiffXmlDifferenceCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RibbonXmlRoot, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleRibbonDifferenceCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.FetchRoot, StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.GridRoot, StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.ColumnSetRoot, StringComparison.InvariantCultureIgnoreCase)
)
{
helper.HandleSavedQueryDifferenceCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.FormXmlRoot, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleSystemFormDifferenceCommand(null, doc, document.FullName);
}
else if (doc.Root.Name == AbstractDynamicCommandXsdSchemas.WorkflowActivityRoot)
{
helper.HandleWorkflowDifferenceCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.WebResourceDependencyXmlRoot, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleWebResourceDependencyXmlDifferenceCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.PluginTypeCustomWorkflowActivityInfoRoot, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandlePluginTypeCustomWorkflowActivityInfoShowDifferenceCommand(null, doc, document.FullName);
}
}
}
}
}
}
protected override void CommandAction(DTEHelper helper)
{
EnvDTE.Document document = helper.GetOpenedDocumentInCodeWindow(FileOperations.SupportsXmlType);
if (document != null)
{
ContentComparerHelper.RemoveXsdSchemaInDocument(document);
}
}
protected override void CommandAction(DTEHelper helper, Tuple <string, string[]> schemas)
{
EnvDTE.Document document = helper.GetOpenedDocumentInCodeWindow(FileOperations.SupportsXmlType);
if (document != null)
{
ContentComparerHelper.ReplaceXsdSchemaInDocument(document, schemas.Item2);
}
}
protected override void CommandAction(DTEHelper helper)
{
EnvDTE.Document document = helper.GetOpenedDocumentInCodeWindow(FileOperations.SupportsXmlType);
if (document != null)
{
ContentComparerHelper.InsertIntellisenseContextEntityNameInDocument(document, string.Empty);
}
}
private async Task PerformExportXmlToFileAsync(string folder, Guid idCustomControl, string name, string fieldName, string fieldTitle, FileExtension extension)
{
if (!this.IsControlsEnabled)
{
return;
}
var service = await GetService();
if (service == null)
{
return;
}
ToggleControls(service.ConnectionData, false, Properties.OutputStrings.ExportingXmlFieldToFileFormat1, fieldTitle);
try
{
var repository = new CustomControlRepository(service);
var customControl = await repository.GetByIdAsync(idCustomControl, new ColumnSet(fieldName));
string xmlContent = customControl.GetAttributeValue <string>(fieldName);
if (!string.IsNullOrEmpty(xmlContent))
{
if (string.Equals(fieldName, CustomControl.Schema.Attributes.manifest, StringComparison.InvariantCultureIgnoreCase))
{
xmlContent = ContentComparerHelper.FormatXmlByConfiguration(
xmlContent
, _commonConfig
, XmlOptionsControls.CustomControlXmlOptions
, schemaName: AbstractDynamicCommandXsdSchemas.ManifestSchema
, customControlId: idCustomControl
);
}
else if (string.Equals(fieldName, CustomControl.Schema.Attributes.clientjson, StringComparison.InvariantCultureIgnoreCase))
{
xmlContent = ContentComparerHelper.FormatJson(xmlContent);
}
}
string filePath = await CreateFileAsync(folder, idCustomControl, name, fieldTitle, extension, xmlContent);
this._iWriteToOutput.PerformAction(service.ConnectionData, filePath);
ToggleControls(service.ConnectionData, true, Properties.OutputStrings.ExportingXmlFieldToFileCompletedFormat1, fieldName);
}
catch (Exception ex)
{
_iWriteToOutput.WriteErrorToOutput(service.ConnectionData, ex);
ToggleControls(service.ConnectionData, true, Properties.OutputStrings.ExportingXmlFieldToFileFailedFormat1, fieldName);
}
}
private async Task PerformShowingDifferenceSingleXmlAsync(LinkedEntities <SiteMap> linked, bool showAllways, string fieldName, string fieldTitle)
{
if (!this.IsControlsEnabled)
{
return;
}
ToggleControls(false, Properties.OutputStrings.ShowingDifferenceXmlForFieldFormat1, fieldName);
try
{
var service1 = await GetService1();
var service2 = await GetService2();
if (service1 != null && service2 != null)
{
var repository1 = new SiteMapRepository(service1);
var repository2 = new SiteMapRepository(service2);
var sitemap1 = await repository1.GetByIdAsync(linked.Entity1.Id, ColumnSetInstances.AllColumns);
var sitemap2 = await repository2.GetByIdAsync(linked.Entity2.Id, ColumnSetInstances.AllColumns);
string xml1 = sitemap1.GetAttributeValue <string>(fieldName);
string xml2 = sitemap2.GetAttributeValue <string>(fieldName);
if (showAllways || !ContentComparerHelper.CompareXML(xml1, xml2).IsEqual)
{
string filePath1 = await CreateFileAsync(service1.ConnectionData, sitemap1.SiteMapName, sitemap1.SiteMapNameUnique, sitemap1.Id, fieldTitle, xml1);
string filePath2 = await CreateFileAsync(service2.ConnectionData, sitemap2.SiteMapName, sitemap2.SiteMapNameUnique, sitemap2.Id, fieldTitle, xml2);
if (File.Exists(filePath1) && File.Exists(filePath2))
{
await this._iWriteToOutput.ProcessStartProgramComparerAsync(service1.ConnectionData, filePath1, filePath2, Path.GetFileName(filePath1), Path.GetFileName(filePath2), service2.ConnectionData);
}
else
{
this._iWriteToOutput.PerformAction(service1.ConnectionData, filePath1);
this._iWriteToOutput.PerformAction(service2.ConnectionData, filePath2);
}
}
}
ToggleControls(true, Properties.OutputStrings.ShowingDifferenceXmlForFieldCompletedFormat1, fieldName);
}
catch (Exception ex)
{
_iWriteToOutput.WriteErrorToOutput(null, ex);
ToggleControls(true, Properties.OutputStrings.ShowingDifferenceXmlForFieldFailedFormat1, fieldName);
}
}
private async Task ExecuteCreatingApplicationRibbon(Func <Task <IOrganizationServiceExtented> > getService)
{
if (!this.IsControlsEnabled)
{
return;
}
var service = await getService();
if (service == null)
{
return;
}
_commonConfig.CheckFolderForExportExists(_iWriteToOutput);
this._iWriteToOutput.WriteToOutputStartOperation(service.ConnectionData, Properties.OperationNames.ExportingApplicationRibbonFormat1, service.ConnectionData.Name);
ToggleControls(false, Properties.OutputStrings.ExportingApplicationRibbon);
try
{
var repository = new RibbonCustomizationRepository(service);
string ribbonXml = await repository.ExportApplicationRibbonAsync();
ribbonXml = ContentComparerHelper.FormatXmlByConfiguration(
ribbonXml
, _commonConfig
, XmlOptionsControls.RibbonXmlOptions
, entityName: string.Empty
);
{
string fileName = EntityFileNameFormatter.GetApplicationRibbonFileName(service.ConnectionData.Name);
string filePath = Path.Combine(_commonConfig.FolderForExport, FileOperations.RemoveWrongSymbols(fileName));
File.WriteAllText(filePath, ribbonXml, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionExportedAppliationRibbonFormat2, service.ConnectionData.Name, filePath);
this._iWriteToOutput.PerformAction(service.ConnectionData, filePath);
}
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(service.ConnectionData, ex);
}
ToggleControls(true, Properties.OutputStrings.ExportingApplicationRibbonCompleted);
this._iWriteToOutput.WriteToOutputEndOperation(service.ConnectionData, Properties.OperationNames.ExportingApplicationRibbonFormat1, service.ConnectionData.Name);
}
protected override void CommandAction(DTEHelper helper, Tuple <string, string[]> schemas)
{
var listDocuments = helper.GetOpenedDocumentsAsDocument(FileOperations.SupportsXmlType).ToList();
if (listDocuments.Any())
{
foreach (var document in listDocuments)
{
ContentComparerHelper.ReplaceXsdSchemaInDocument(document, schemas.Item2);
}
}
}
protected override void CommandAction(DTEHelper helper)
{
List <EnvDTE.Document> listDocuments = helper.GetOpenedDocumentsAsDocument(FileOperations.SupportsXmlType).ToList();
if (listDocuments.Any())
{
foreach (var document in listDocuments)
{
ContentComparerHelper.RemoveAllCustomAttributesInDocument(document);
}
}
}
protected override void CommandAction(DTEHelper helper)
{
var document = helper.GetOpenedDocumentInCodeWindow(FileOperations.SupportsXmlType);
if (document != null)
{
var objTextDoc = document.Object("TextDocument");
if (objTextDoc != null &&
objTextDoc is EnvDTE.TextDocument textDocument
)
{
string text = textDocument.StartPoint.CreateEditPoint().GetText(textDocument.EndPoint);
if (!string.IsNullOrEmpty(text))
{
if (ContentComparerHelper.TryParseXmlDocument(text, out var doc))
{
string docRootName = doc.Root.Name.ToString();
if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RootSiteMap, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleSiteMapUpdateCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RootRibbonDiffXml, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleRibbonDiffXmlUpdateCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RootFetch, StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RootGrid, StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RootColumnSet, StringComparison.InvariantCultureIgnoreCase)
)
{
helper.HandleSavedQueryUpdateCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RootForm, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleSystemFormUpdateCommand(null, doc, document.FullName);
}
else if (doc.Root.Name == AbstractDynamicCommandXsdSchemas.RootActivity)
{
helper.HandleWorkflowUpdateCommand(null, doc, document.FullName);
}
else if (string.Equals(docRootName, AbstractDynamicCommandXsdSchemas.RootWebResourceDependencies, StringComparison.InvariantCultureIgnoreCase))
{
helper.HandleWebResourceDependencyXmlUpdateCommand(null, doc, document.FullName);
}
}
}
}
}
}
private async Task PerformExportXmlToFileAsync(Guid idWebResource, Func <Task <IOrganizationServiceExtented> > getService, string fieldName, string fieldTitle, FileExtension extension)
{
if (!this.IsControlsEnabled)
{
return;
}
ToggleControls(false, Properties.OutputStrings.ExportingXmlFieldToFileFormat1, fieldTitle);
var service = await getService();
if (service != null)
{
var repository = new WebResourceRepository(service);
var webResource = await repository.GetByIdAsync(idWebResource, ColumnSetInstances.AllColumns);
string xmlContent = webResource.GetAttributeValue <string>(fieldName);
if (!string.IsNullOrEmpty(xmlContent))
{
if (string.Equals(fieldName, WebResource.Schema.Attributes.dependencyxml, StringComparison.InvariantCultureIgnoreCase))
{
xmlContent = ContentComparerHelper.FormatXmlByConfiguration(
xmlContent
, _commonConfig
, XmlOptionsControls.WebResourceDependencyXmlOptions
, schemaName: AbstractDynamicCommandXsdSchemas.WebResourceDependencyXmlSchema
, webResourceName: webResource.Name
);
}
else if (string.Equals(fieldName, WebResource.Schema.Attributes.contentjson, StringComparison.InvariantCultureIgnoreCase))
{
xmlContent = ContentComparerHelper.FormatJson(xmlContent);
}
}
string filePath = await CreateFileAsync(service.ConnectionData, webResource.Name, fieldTitle, xmlContent, extension);
if (!File.Exists(filePath))
{
this._iWriteToOutput.WriteToOutput(null, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, service.ConnectionData.Name, Report.Schema.EntityLogicalName, webResource.Name, fieldTitle);
this._iWriteToOutput.ActivateOutputWindow(null);
}
this._iWriteToOutput.PerformAction(service.ConnectionData, filePath);
}
ToggleControls(true, Properties.OutputStrings.ExportingXmlFieldToFileCompletedFormat1, fieldName);
}
private static bool ValidateXmlDocument(ConnectionData connectionData, IWriteToOutput iWriteToOutput, XDocument doc)
{
ContentComparerHelper.ClearRoot(doc);
XmlSchemaSet schemas = new XmlSchemaSet();
{
var schemasResources = AbstractDynamicCommandXsdSchemas.GetXsdSchemas(AbstractDynamicCommandXsdSchemas.WebResourceDependencyXmlSchema);
if (schemasResources != null)
{
foreach (var fileName in schemasResources)
{
Uri uri = FileOperations.GetSchemaResourceUri(fileName);
StreamResourceInfo info = Application.GetResourceStream(uri);
using (StreamReader reader = new StreamReader(info.Stream))
{
schemas.Add(string.Empty, XmlReader.Create(reader));
}
}
}
}
List <ValidationEventArgs> errors = new List <ValidationEventArgs>();
doc.Validate(schemas, (o, e) =>
{
errors.Add(e);
});
if (errors.Count > 0)
{
iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.TextIsNotValidForFieldFormat1, AbstractDynamicCommandXsdSchemas.WebResourceDependencyXmlSchema);
foreach (var item in errors)
{
iWriteToOutput.WriteToOutput(connectionData, string.Empty);
iWriteToOutput.WriteToOutput(connectionData, string.Empty);
iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.XmlValidationMessageFormat2, item.Severity, item.Message);
iWriteToOutput.WriteErrorToOutput(connectionData, item.Exception);
}
iWriteToOutput.ActivateOutputWindow(connectionData);
}
return(errors.Count == 0);
}
protected override void CommandAction(DTEHelper helper, Tuple <ConnectionData, ConnectionData> connectionDataPair)
{
List <SelectedFile> selectedFiles = helper.GetOpenedFileInCodeWindow(FileOperations.SupportsXmlType).Take(2).ToList();
if (selectedFiles.Count == 1)
{
string fileText = File.ReadAllText(selectedFiles[0].FilePath);
if (ContentComparerHelper.TryParseXml(fileText, out var doc))
{
var webResourceNameAttribute = doc.Attribute(Intellisense.Model.IntellisenseContext.IntellisenseContextAttributeWebResourceName);
helper.HandleOpenWebResourceOrganizationComparerCommand(connectionDataPair.Item1, connectionDataPair.Item2, webResourceNameAttribute?.Value);
}
}
}
protected override void CommandAction(DTEHelper helper)
{
List <SelectedFile> selectedFiles = helper.GetOpenedFileInCodeWindow(FileOperations.SupportsXmlType).Take(2).ToList();
if (selectedFiles.Count == 1)
{
string fileText = File.ReadAllText(selectedFiles[0].FilePath);
if (ContentComparerHelper.TryParseXml(fileText, out var doc))
{
var attribute = doc.Attribute(Intellisense.Model.IntellisenseContext.IntellisenseContextAttributeWorkflowId);
helper.HandleExplorerWorkflows(attribute?.Value);
}
}
}
protected override void CommandAction(DTEHelper helper)
{
List <SelectedFile> selectedFiles = helper.GetOpenedFileInCodeWindow(FileOperations.SupportsXmlType).Take(2).ToList();
if (selectedFiles.Count == 1)
{
string fileText = File.ReadAllText(selectedFiles[0].FilePath);
if (ContentComparerHelper.TryParseXml(fileText, out var doc))
{
var pluginTypeName = doc.XPathSelectElements("./CustomActivityInfo/TypeName").Where(e => !string.IsNullOrEmpty(e.Value)).Select(e => e.Value).FirstOrDefault();
helper.HandleOpenPluginTypeExplorer(pluginTypeName);
}
}
}
protected override void CommandAction(DTEHelper helper, Tuple <string, string[]> schemas)
{
var listFiles = helper.GetSelectedFilesInSolutionExplorer(FileOperations.SupportsXmlType, false);
if (listFiles.Any())
{
foreach (var document in listFiles.Where(s => s.Document != null && s.Document.ActiveWindow != null && s.Document.ActiveWindow.Visible).Select(s => s.Document))
{
ContentComparerHelper.ReplaceXsdSchemaInDocument(document, schemas.Item2);
}
foreach (var filePath in listFiles.Where(s => !(s.Document != null && s.Document.ActiveWindow != null && s.Document.ActiveWindow.Visible)).Select(s => s.FilePath))
{
ContentComparerHelper.ReplaceXsdSchemaInFile(filePath, schemas.Item2);
}
}
}
protected override void CommandAction(DTEHelper helper)
{
var listFiles = _sourceSelectedFiles.GetSelectedFiles(helper, SelectedFileType.Xml).ToList();
if (listFiles.Any())
{
foreach (var document in listFiles.Where(s => s.Document != null && s.Document.ActiveWindow != null && s.Document.ActiveWindow.Visible).Select(s => s.Document))
{
ContentComparerHelper.RemoveXsdSchemaInDocument(document);
}
foreach (var filePath in listFiles.Where(s => !(s.Document != null && s.Document.ActiveWindow != null && s.Document.ActiveWindow.Visible)).Select(s => s.FilePath))
{
ContentComparerHelper.RemoveXsdSchemaInFile(filePath);
}
}
}
protected override void CommandAction(DTEHelper helper)
{
var listFiles = helper.GetSelectedFilesInSolutionExplorer(FileOperations.SupportsXmlType, true).ToList();
if (listFiles.Any())
{
foreach (var document in listFiles.Where(s => s.Document != null && s.Document.ActiveWindow != null && s.Document.ActiveWindow.Visible).Select(s => s.Document))
{
ContentComparerHelper.RemoveAllCustomAttributesInDocument(document);
}
foreach (var filePath in listFiles.Where(s => !(s.Document != null && s.Document.ActiveWindow != null && s.Document.ActiveWindow.Visible)).Select(s => s.FilePath))
{
ContentComparerHelper.RemoveAllCustomAttributesInFile(filePath);
}
}
}