Analysis-Services/MetadataTranslator/Metadata Translator/UI/MainWindow.xaml.cs

635 lines
23 KiB
C#
Raw Normal View History

using Microsoft.AnalysisServices.Tabular;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Configuration;
using System.Dynamic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Net.Http;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Web.Script.Serialization;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
namespace Metadata_Translator
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
SetDependencyProperty("SubscriptionKey");
SetDependencyProperty("TranslatorEndpoint");
SetDependencyProperty("TranslatorLocation");
SetDependencyProperty("OverwriteTranslation");
SetDependencyProperty("LastUsedExportFolder");
if (string.IsNullOrEmpty(SubscriptionKey))
{
SettingsToggle.IsChecked = true;
}
}
public MainWindow(StartupEventArgs e) : this()
{
if (e.Args.Length == 2)
{
ConnectToDataset(e.Args[0], e.Args[1]);
}
}
public void AddColumn(string lcid)
{
Language language = DataModel.GetLanguageByLcid(lcid);
if (language != null)
{
dataGrid.Columns.Add(new DataGridTextColumn
{
Header = language.DisplayName,
Binding = new Binding(lcid)
});
language.IsSelected = true;
}
}
/// <summary>
/// Connects to the dataset using a connection string.
/// </summary>
/// <param name="connectionString"></param>
public void ConnectToDataset(string connectionString)
{
try
{
DataModel = DataModel.Connect(connectionString);
InitTranslationUI();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Connects to the dataset via server and database name.
/// </summary>
/// <param name="server"></param>
/// <param name="database"></param>
public void ConnectToDataset(string server, string database)
{
try
{
DataModel = DataModel.Connect(server, database);
InitTranslationUI();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
}
#region Helper functions
/// <summary>
/// Initializes the translation grid.
/// </summary>
private void InitTranslationUI()
{
PowerBIEngine = DataModel.ServerName;
DatabaseName = DataModel.DatabaseName;
SetDependencyProperty("Languages");
InitializeDataGrid();
}
/// <summary>
/// Set Dependency Properties that wrap apps ettings.
/// </summary>
/// <param name="parameterName"></param>
private void SetDependencyProperty(string parameterName)
{
switch (parameterName)
{
case "SubscriptionKey":
SubscriptionKey = Properties.Settings.Default.SubscriptionKey;
break;
case "TranslatorEndpoint":
TranslatorEndpoint = Properties.Settings.Default.TranslatorEndpoint;
break;
case "TranslatorLocation":
TranslatorLocation = Properties.Settings.Default.TranslatorLocation;
break;
case "OverwriteTranslation":
OverwriteTranslation = Properties.Settings.Default.OverwriteTranslation;
break;
case "LastUsedExportFolder":
LastUsedExportFolder = Properties.Settings.Default.LastUsedExportFolder;
break;
case "Languages":
Languages = new ObservableCollection<Language>();
foreach (var language in DataModel.SupportedLanguages)
{
Languages.Add(language);
}
break;
}
}
/// <summary>
/// Initializes the datagrid columns and sets the ItemsSource to the default collection.
/// </summary>
private void InitializeDataGrid()
{
List<string> cultures = DataModel.CultureNames;
/// Create some setters and triggers for the
/// styles of the read-only columns.
///
Trigger iIsSelectedTrigger = new Trigger()
{
Property = DataGridTextColumn.IsReadOnlyProperty,
Value = true
};
var foregroundSetter = new Setter(DataGridCell.ForegroundProperty, new SolidColorBrush(Colors.Black));
iIsSelectedTrigger.Setters.Add(foregroundSetter);
var backgroundSetter = new Setter(DataGridCell.BackgroundProperty, new SolidColorBrush(Colors.LightGray));
/// The first column is for the metadata container object.
///
var objectColumnStyle = new Style(typeof(DataGridCell));
objectColumnStyle.Setters.Add(backgroundSetter);
objectColumnStyle.Setters.Add(foregroundSetter);
objectColumnStyle.Triggers.Add(iIsSelectedTrigger);
dataGrid.Columns.Add(new DataGridTextColumn
{
Header = FindResource("TabularObjectColumnHeader").ToString(),
Binding = new Binding(DataModel.ContainerColumnHeader),
IsReadOnly = true,
CellStyle = objectColumnStyle
});
/// The second column is for the default culture of the data model,
/// which is always the first language in the list of data model cultures.
///
var defaultLangColumnStyle = new Style(typeof(DataGridCell));
defaultLangColumnStyle.Setters.Add(foregroundSetter);
defaultLangColumnStyle.Triggers.Add(iIsSelectedTrigger);
/// Add a tooltip to flag that the default culture is readonly.
///
var objectHeaderStyle = new Style(typeof(DataGridColumnHeader));
objectHeaderStyle.Setters.Add(new Setter(ToolTipService.ToolTipProperty,
FindResource("DefaultCultureColumnHeaderToolTip").ToString()));
Language defaultLang = DataModel.GetLanguageByLcid(cultures[0]);
dataGrid.Columns.Add(new DataGridTextColumn
{
Header = $"{defaultLang.DisplayName}*",
HeaderStyle = objectHeaderStyle,
Binding = new Binding(cultures[0]),
IsReadOnly = true,
CellStyle = defaultLangColumnStyle
});
DataModel.SetLanguageFlags(cultures[0], true, true);
/// Add the remaining languages that already exist in the data model
/// and mark them as selected in the list of supported languages.
///
for (int i = 1; i< cultures.Count; i++)
{
AddColumn(cultures[i]);
}
/// And set Captions as the default content of the datagrid.
dataGrid.ItemsSource = DataModel.Captions;
}
/// <summary>
/// Get a handle to the main window object so that other user controls can
/// access the public properties of the main window object directly.
/// </summary>
/// <param name="child"></param>
/// <returns></returns>
public static MainWindow GetMainWindow(DependencyObject child)
{
if (child == null) return null;
DependencyObject parentObject = VisualTreeHelper.GetParent(child);
if (parentObject is MainWindow parent)
{
return parent;
}
else
{
return GetMainWindow(parentObject);
}
}
#endregion
#region Dependency Properties
/// <summary>
/// DataModel object
/// </summary>
public static readonly DependencyProperty DataModelProperty =
DependencyProperty.Register("DataModel", typeof(DataModel), typeof(MainWindow));
public DataModel DataModel
{
get { return (DataModel)GetValue(DataModelProperty); }
set { SetValue(DataModelProperty, value); }
}
/// <summary>
/// Supported languages collection
/// </summary>
public static readonly DependencyProperty LanguagesProperty =
DependencyProperty.Register("Languages", typeof(ObservableCollection<Language>), typeof(MainWindow),
new PropertyMetadata(null, new PropertyChangedCallback(OnLanguagesChanged)));
public ObservableCollection<Language> Languages
{
get { return (ObservableCollection<Language>)GetValue(LanguagesProperty); }
set { SetValue(LanguagesProperty, value); }
}
private static void OnLanguagesChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
(sender as MainWindow).OnLanguagesChanged(e);
}
private void OnLanguagesChanged(DependencyPropertyChangedEventArgs e)
{
if (e.NewValue is ObservableCollection<Language> newCollection)
{
newCollection.CollectionChanged += LanguagesCollection_Changed;
if (newCollection.Count > 0)
AttachLanguagePropertyChangedEventHandler(newCollection);
}
else if (e.OldValue is ObservableCollection<Language> oldCollection)
{
oldCollection.CollectionChanged -= LanguagesCollection_Changed;
if (oldCollection.Count > 0)
RemoveLanguagePropertyChangedEventHandler(oldCollection);
}
}
private void LanguagesCollection_Changed(object sender, NotifyCollectionChangedEventArgs e)
{
switch(e.Action)
{
case NotifyCollectionChangedAction.Add:
AttachLanguagePropertyChangedEventHandler(e.NewItems);
break;
case NotifyCollectionChangedAction.Remove:
RemoveLanguagePropertyChangedEventHandler(e.OldItems);
break;
case NotifyCollectionChangedAction.Replace:
RemoveLanguagePropertyChangedEventHandler(e.OldItems);
AttachLanguagePropertyChangedEventHandler(e.NewItems);
break;
default:
throw new NotSupportedException();
}
}
private void AttachLanguagePropertyChangedEventHandler(System.Collections.IList items)
{
foreach (Language language in items)
{
language.PropertyChanged += LanguageProperty_Changed;
}
}
private void RemoveLanguagePropertyChangedEventHandler(System.Collections.IList items)
{
foreach (Language language in items)
{
language.PropertyChanged -= LanguageProperty_Changed;
}
}
/// <summary>
/// Event handler for LanguageProperty_Changed event to add or remove a lanugage
/// from the datagrid headers.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void LanguageProperty_Changed(object sender, PropertyChangedEventArgs e)
{
if(sender is Language language
&& e.PropertyName == "IsSelected"
&& !language.LanguageTag.Equals(DataModel.DefaultCulture))
{
var existingColumn = dataGrid.Columns.Where(x => language.DisplayName.Equals(x.Header.ToString())).FirstOrDefault();
if (language.IsSelected)
{
if (existingColumn == null)
{
dataGrid.Columns.Add(new DataGridTextColumn
{
Header = language.DisplayName,
Binding = new Binding(language.LanguageTag)
});
}
}
else
{
if (existingColumn != null)
{
dataGrid.Columns.Remove(existingColumn);
}
}
}
}
/// <summary>
/// SubscriptionKey Property
/// </summary>
public static readonly DependencyProperty SubscriptionKeyProperty =
DependencyProperty.Register("SubscriptionKey", typeof(string), typeof(MainWindow),
new PropertyMetadata(new PropertyChangedCallback(OnSubscriptionKeyChanged)));
public string SubscriptionKey
{
get { return (string)GetValue(SubscriptionKeyProperty); }
set { SetValue(SubscriptionKeyProperty, value); }
}
private static void OnSubscriptionKeyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Properties.Settings.Default.SubscriptionKey = (string)e.NewValue;
}
/// <summary>
/// TranslatorEndpoint Property
/// </summary>
public static readonly DependencyProperty TranslatorEndpointProperty =
DependencyProperty.Register("TranslatorEndpoint", typeof(string), typeof(MainWindow),
new PropertyMetadata(new PropertyChangedCallback(OnTranslatorEndpointChanged)));
public string TranslatorEndpoint
{
get { return (string)GetValue(TranslatorEndpointProperty); }
set { SetValue(TranslatorEndpointProperty, value); }
}
private static void OnTranslatorEndpointChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Properties.Settings.Default.TranslatorEndpoint = (string)e.NewValue;
}
/// <summary>
/// TranslatorLocation Property
/// </summary>
public static readonly DependencyProperty TranslatorLocationProperty =
DependencyProperty.Register("TranslatorLocation", typeof(string), typeof(MainWindow),
new PropertyMetadata(new PropertyChangedCallback(OnTranslatorLocationChanged)));
public string TranslatorLocation
{
get { return (string)GetValue(TranslatorLocationProperty); }
set { SetValue(TranslatorLocationProperty, value); }
}
private static void OnTranslatorLocationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Properties.Settings.Default.TranslatorLocation = (string)e.NewValue;
}
/// <summary>
/// OverwriteTranslation Property
/// </summary>
public static readonly DependencyProperty OverwriteTranslationProperty =
DependencyProperty.Register("OverwriteTranslation", typeof(bool), typeof(MainWindow),
new PropertyMetadata(new PropertyChangedCallback(OnOverwriteTranslationChanged)));
public bool OverwriteTranslation
{
get { return (bool)GetValue(OverwriteTranslationProperty); }
set { SetValue(OverwriteTranslationProperty, value); }
}
private static void OnOverwriteTranslationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Properties.Settings.Default.OverwriteTranslation = (bool)e.NewValue;
}
/// <summary>
/// LastUsedExportFolder Property
/// </summary>
public static readonly DependencyProperty LastUsedExportFolderProperty =
DependencyProperty.Register("LastUsedExportFolder", typeof(string), typeof(MainWindow),
new PropertyMetadata(new PropertyChangedCallback(OnLastUsedExportFolderChanged)));
public string LastUsedExportFolder
{
get { return (string)GetValue(LastUsedExportFolderProperty); }
set { SetValue(LastUsedExportFolderProperty, value); }
}
private static void OnLastUsedExportFolderChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Properties.Settings.Default.LastUsedExportFolder = (string)e.NewValue;
}
/// <summary>
/// PowerBIEngine Property
/// </summary>
public static readonly DependencyProperty PowerBIEngineProperty =
DependencyProperty.Register("PowerBIEngine", typeof(string), typeof(MainWindow));
public string PowerBIEngine
{
set { SetValue(PowerBIEngineProperty, value); }
get { return (string)GetValue(PowerBIEngineProperty); }
}
/// <summary>
/// DatabaseName Property
/// </summary>
public static readonly DependencyProperty DatabaseNameProperty =
DependencyProperty.Register("DatabaseName", typeof(string), typeof(MainWindow));
public string DatabaseName
{
set { SetValue(DatabaseNameProperty, value); }
get { return (string)GetValue(DatabaseNameProperty); }
}
#endregion
#region Event Handlers
/// <summary>
/// Event handler for ToolBar_Loaded event to remove some of the
/// unnecessary standard UI elements of the toolbar.
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ToolBar_Loaded(object sender, RoutedEventArgs e)
{
if(sender is ToolBar toolBar)
{
if (toolBar.Template.FindName("OverflowGrid", toolBar) is FrameworkElement overflowGrid)
{
overflowGrid.Visibility = Visibility.Collapsed;
}
if (toolBar.Template.FindName("MainPanelBorder", toolBar) is FrameworkElement mainPanelBorder)
{
mainPanelBorder.Margin = new Thickness();
}
}
}
/// <summary>
/// Enabling the deselect of a selected toggle button on mouseclick.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnToggleButton_Click(object sender, RoutedEventArgs e)
{
if(sender is RadioButton radio)
{
bool tagState = (radio.Tag == null);
radio.Tag = (radio.Tag == null) ? new object() : null;
radio.IsChecked = tagState;
}
}
/// <summary>
/// Unsets the tag that indicates if a toggle button was clicked to be deselected.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnToggleButton_Uncheck(object sender, RoutedEventArgs e)
{
if (sender is RadioButton radio)
{
radio.Tag = null;
}
}
/// <summary>
/// Display the Captions in the datagrid.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnCaptionRadioButton_Click(object sender, RoutedEventArgs e)
{
if (DataModel != null)
{
dataGrid.ItemsSource = DataModel.Captions;
}
}
/// <summary>
/// Display the Descriptions in the datagrid.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnDescriptionRadioButton_Click(object sender, RoutedEventArgs e)
{
if (DataModel != null)
{
dataGrid.ItemsSource = DataModel.Descriptions;
}
}
/// <summary>
/// Display the DisplayFolder strings in the datagrid.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnDisplayFolderRadioButton_Click(object sender, RoutedEventArgs e)
{
if (DataModel != null)
{
dataGrid.ItemsSource = DataModel.DisplayFolders;
}
}
/// <summary>
/// Make the terms in the default culture more translatable by splitting the strings
/// based on camel casing.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnPrepareButton_Click(object sender, RoutedEventArgs e)
{
if (DataModel == null) return;
string defaultCulture = DataModel.DefaultCulture;
foreach(ExpandoObject row in DataModel.GetAllDataRows())
{
((IDictionary<String, Object>)row)[defaultCulture] = row.SeparateCamelCase(defaultCulture);
}
}
/// <summary>
/// Translate the strings tn the default culture into the
/// selected target languages.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnTranslateButton_Click(object sender, RoutedEventArgs e)
{
if (DataModel.HasTargetLanguages)
{
using (new Hourglass())
{
var ts = new TranslatorService(Languages.Where(x => x.IsSelected == true)?.ToList(), DataModel.DefaultCulture, SubscriptionKey, TranslatorEndpoint, TranslatorLocation);
ts.Translate(DataModel.GetAllDataRows(), OverwriteTranslation);
}
}
else
{
MessageBox.Show(FindResource("NothingToTranslate").ToString());
LanguageToggle.IsChecked = true;
}
}
/// <summary>
/// Apply the current values in the Captions, Descriptions, and DisplayFolders collections to the data model.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnApplyButton_Click(object sender, RoutedEventArgs e)
{
DataModel.Update();
}
/// <summary>
/// Saves modified user settings.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnMainWindow_Closing(object sender, CancelEventArgs e)
{
Properties.Settings.Default.Save();
}
#endregion
}
}