944 lines
37 KiB
C#
944 lines
37 KiB
C#
using BeWo.Core;
|
|
using BeWo.Core.Service;
|
|
using BeWo.ServiceProxy;
|
|
using BeWo.View.Controls;
|
|
using BeWo.View.Detail.Report;
|
|
using BeWo.ViewModel;
|
|
using BeWo.ViewModel.ListViewModel;
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.ClientPartials;
|
|
using BS.Shared.Extensions;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Controls.Primitives;
|
|
using System.Windows.Data;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Windows.Threading;
|
|
|
|
namespace BeWo.View.Detail
|
|
{
|
|
public enum MassnahmenTreeCopyType
|
|
{
|
|
Node, Subtree
|
|
}
|
|
|
|
public partial class MassnahmenTreeViewView
|
|
{
|
|
private bool _Bearbeitungsmodus;
|
|
|
|
private TreeViewItem _SelectedGoalTreeNode;
|
|
private GenericValueListEntryListVM _ViewModel;
|
|
private List<ValueListEntryDC> _Children2Delete;
|
|
private List<SupportConceptGoalTreeItem> _TreeViewItemsList;
|
|
|
|
private MassnahmenTreeCopyType _CopyType;
|
|
private SupportConceptGoalTreeItem _CopyItem;
|
|
private Point _lastMouseDown;
|
|
private SupportConceptGoalTreeItem _draggedItem;
|
|
private SupportConceptGoalTreeItem _parent;
|
|
|
|
public MassnahmenTreeViewView(GenericValueListEntryListVM pViewModel)
|
|
{
|
|
InitializeComponent();
|
|
|
|
ViewModel = pViewModel;
|
|
|
|
DataContext = this;
|
|
|
|
Bearbeitungsmodus = false;
|
|
}
|
|
|
|
public static bool IsAllowedToEditGoals => BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConcept_AllowEditGoals);
|
|
|
|
public GenericValueListEntryListVM ViewModel
|
|
{
|
|
get => _ViewModel;
|
|
set
|
|
{
|
|
_ViewModel = value;
|
|
InitGoalCategoriesTreeView();
|
|
TreeView.ItemsSource = GoalTree;
|
|
}
|
|
}
|
|
|
|
public bool Bearbeitungsmodus
|
|
{
|
|
get
|
|
{
|
|
return _Bearbeitungsmodus;
|
|
}
|
|
set
|
|
{
|
|
// Wenn True aber keine Rechte
|
|
if (value && !IsAllowedToEditGoals)
|
|
return;
|
|
|
|
_Bearbeitungsmodus = value;
|
|
|
|
TreeView.AllowDrop = _Bearbeitungsmodus;
|
|
}
|
|
}
|
|
|
|
public ObservableSortCollection<SupportConceptGoalTreeItem> GoalTree { get; private set; }
|
|
|
|
public override bool IsDirty => ViewModel != null && ViewModel.IsDirty;
|
|
|
|
private void GoalTreeViewItem_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
var source = e.OriginalSource as DependencyObject;
|
|
while (source != null && !(source is TreeViewItem))
|
|
{
|
|
source = VisualTreeHelper.GetParent(source);
|
|
}
|
|
|
|
if (source != null)
|
|
{
|
|
((TreeViewItem)source).IsSelected = true;
|
|
_SelectedGoalTreeNode = (TreeViewItem)source;
|
|
}
|
|
else
|
|
{
|
|
_SelectedGoalTreeNode = null;
|
|
}
|
|
|
|
if (e.ChangedButton == MouseButton.Left)
|
|
{
|
|
_lastMouseDown = e.GetPosition(TreeView);
|
|
}
|
|
}
|
|
private void TextBox_LostFocus(object sender, RoutedEventArgs e)
|
|
{
|
|
UpdateSelectedTreeItemText((TextBox)sender);
|
|
}
|
|
private void TextBox_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.Key == Key.Return)
|
|
{
|
|
UpdateSelectedTreeItemText((TextBox)sender);
|
|
}
|
|
}
|
|
private void ContextMenuGoals_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if (!(e.OriginalSource is MenuItem twi)) return;
|
|
|
|
var selectedItem = TreeView.SelectedItem as SupportConceptGoalTreeItem;
|
|
|
|
switch (twi.Header)
|
|
{
|
|
case "Neue Maßnahme":
|
|
if (_SelectedGoalTreeNode != null)
|
|
{
|
|
AddTreeItemWithControl(selectedItem, ValueListEntryType.SupportConceptGoalType, "Maßnahme hinzufügen");
|
|
}
|
|
break;
|
|
case "Neues Ziel":
|
|
if (_SelectedGoalTreeNode != null)
|
|
{
|
|
AddTreeItemWithControl(selectedItem, ValueListEntryType.SupportConceptGoalCategoryType, "Ziel hinzufügen");
|
|
}
|
|
break;
|
|
case "Löschen":
|
|
if (selectedItem != null)
|
|
{
|
|
var zielOderMassnahme = selectedItem.GoalEntryVM.Type == ValueListEntryType.SupportConceptGoalCategoryType ? "das Ziel" : "die Maßnahme";
|
|
var pluralendung = zielOderMassnahme.Equals("das Ziel") ? "en" : "n";
|
|
|
|
if (MessageBox.Show("ACHTUNG: Das Löschen von " + zielOderMassnahme.Substring(4) + pluralendung + " kann nicht rückgängig gemacht werden.\n" +
|
|
"Alle verknüpften Eintragungen in der Zeiterfassung bleiben erhalten.\n\n" +
|
|
"Wollen Sie " + zielOderMassnahme + " '" + selectedItem.GoalEntryVM?.DisplayName + "' wirklich löschen?", "Löschen bestätigen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
|
|
{
|
|
DeleteIndividualGoal(selectedItem);
|
|
}
|
|
}
|
|
break;
|
|
case "Bearbeiten":
|
|
if (selectedItem != null)
|
|
EditTreeItem(selectedItem.GoalEntryVM);
|
|
break;
|
|
case "Knoten kopieren":
|
|
if (selectedItem != null)
|
|
{
|
|
_CopyItem = selectedItem;
|
|
_CopyType = MassnahmenTreeCopyType.Node;
|
|
}
|
|
break;
|
|
case "Teilbaum kopieren":
|
|
if (selectedItem != null)
|
|
{
|
|
_CopyItem = selectedItem;
|
|
_CopyType = MassnahmenTreeCopyType.Subtree;
|
|
}
|
|
break;
|
|
case "Einfügen":
|
|
if (!_Bearbeitungsmodus)
|
|
{
|
|
MessageBox.Show("Bearbeitungsmodus deaktiviert", "Aktion nicht möglich");
|
|
}
|
|
else
|
|
{
|
|
if (selectedItem != null)
|
|
CopyTreeItem(selectedItem, _CopyItem, false);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
private void ContextMenuGoals_Opened(object sender, RoutedEventArgs e)
|
|
{
|
|
if (e.OriginalSource is ContextMenu menu)
|
|
{
|
|
var goal = TreeView.SelectedItem as SupportConceptGoalTreeItem;
|
|
|
|
foreach (var menuitem in menu.Items.OfType<MenuItem>().Select(item => item))
|
|
{
|
|
if (menuitem.Header.Equals("Neue Maßnahme"))
|
|
{
|
|
menuitem.IsEnabled = goal != null && !goal.IsGoal;
|
|
}
|
|
else if (menuitem.Header.Equals("Neues Ziel"))
|
|
{
|
|
menuitem.IsEnabled = goal != null && !goal.IsGoal;
|
|
}
|
|
else if (menuitem.Header.Equals("Notiz bearbeiten"))
|
|
{
|
|
menuitem.IsEnabled = goal != null; // && goal.IsGoal;
|
|
}
|
|
else if (menuitem.Header.Equals("Einfügen"))
|
|
{
|
|
menuitem.IsEnabled = goal != null && !goal.IsGoal && Bearbeitungsmodus && _CopyItem != null;
|
|
}
|
|
else if (menuitem.Header.Equals("Teilbaum kopieren"))
|
|
{
|
|
menuitem.IsEnabled = goal != null && !goal.IsGoal && Bearbeitungsmodus;
|
|
}
|
|
else if (menuitem.Header.Equals("Knoten kopieren"))
|
|
{
|
|
menuitem.IsEnabled = goal != null && !goal.IsGoal && Bearbeitungsmodus;
|
|
}
|
|
|
|
menuitem.IsEnabled = menuitem.IsEnabled && IsAllowedToEditGoals;
|
|
}
|
|
}
|
|
}
|
|
private void GoalTreeItemContainerGenerator_StatusChanged(object sender, EventArgs e)
|
|
{
|
|
var ig = (ItemContainerGenerator)sender;
|
|
if (ig.Status != GeneratorStatus.ContainersGenerated)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (ig.ContainerFromIndex(_SelectedGoalTreeNode.Items.Count - 1) is TreeViewItem n)
|
|
{
|
|
n.IsSelected = true;
|
|
|
|
new DispatcherTimer(
|
|
TimeSpan.FromMilliseconds(200),
|
|
DispatcherPriority.Background,
|
|
(s1, e1) =>
|
|
{
|
|
_SelectedGoalTreeNode = n;
|
|
var item = ig.ItemFromContainer(n) as SupportConceptGoalDC;
|
|
EditItem(TreeView, _SelectedGoalTreeNode, item);
|
|
((DispatcherTimer)s1).Stop();
|
|
},
|
|
Dispatcher).Start();
|
|
}
|
|
|
|
_SelectedGoalTreeNode.ItemContainerGenerator.StatusChanged -= GoalTreeItemContainerGenerator_StatusChanged;
|
|
}
|
|
private void ZielHinzufuegenButton_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var newItem = new SupportConceptGoalTreeItem();
|
|
var vm = ViewModel.NewVM;
|
|
vm.Type = ValueListEntryType.SupportConceptGoalCategoryType;
|
|
|
|
newItem.GoalEntryVM = vm;
|
|
ViewModel.AddNewVMToList();
|
|
|
|
GoalTree.Add(newItem);
|
|
|
|
GoalTree.Sort((x, y) => x.GoalEntryVM?.DisplayName?.CompareTo(y.GoalEntryVM?.DisplayName) ?? string.Compare(string.Empty, y.GoalEntryVM?.DisplayName, StringComparison.Ordinal));
|
|
}
|
|
private void IcfImport_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var vorhandeneZiele = new List<ValueListEntryDC>();
|
|
|
|
foreach (var item in GoalTree)
|
|
{
|
|
vorhandeneZiele.AddRange(GetAllChildren(item, null));
|
|
}
|
|
|
|
//#if DEBUG
|
|
var control2 = new IcfImportControl(ServiceFacade.DoOperationsServiceSync(x => x.GetWholeIcfOhneImportierte(vorhandeneZiele)));
|
|
|
|
var beWoWindow2 = new BeWoWindow
|
|
{
|
|
rootGroupBox = { Header = "Icf Importieren" },
|
|
Height = 500,
|
|
Width = 500,
|
|
WindowStartupLocation = WindowStartupLocation.CenterOwner,
|
|
GroupBoxContent = control2,
|
|
Owner = BeWoApp.CurrentBeWo.MainWindow
|
|
};
|
|
|
|
control2.ButtonImportClicked += () =>
|
|
{
|
|
ImportIcf(control2.TreeViewGoalItem);
|
|
beWoWindow2.Close();
|
|
};
|
|
|
|
control2.ButtonCancelClicked += () =>
|
|
{
|
|
beWoWindow2.Close();
|
|
};
|
|
|
|
beWoWindow2.ShowDialog();
|
|
|
|
return;
|
|
//#endif
|
|
//var control = new IcfImportControl(ServiceFacade.DoOperationsServiceSync(x => x.GetWholeIcf()));
|
|
|
|
//var beWoWindow = new BeWoWindow
|
|
//{
|
|
// rootGroupBox = { Header = "Icf Importieren" },
|
|
// Height = 500,
|
|
// Width = 500,
|
|
// WindowStartupLocation = WindowStartupLocation.CenterOwner,
|
|
// GroupBoxContent = control,
|
|
// Owner = BeWoApp.CurrentBeWo.MainWindow
|
|
//};
|
|
|
|
//control.ButtonImportClicked += () =>
|
|
//{
|
|
// ImportIcf(control.TreeViewGoalItem);
|
|
// beWoWindow.Close();
|
|
//};
|
|
|
|
//control.ButtonCancelClicked += () =>
|
|
//{
|
|
// beWoWindow.Close();
|
|
//};
|
|
|
|
//beWoWindow.ShowDialog();
|
|
}
|
|
|
|
private void ToggleButton_Checked(object sender, RoutedEventArgs e)
|
|
{
|
|
Bearbeitungsmodus = true;
|
|
}
|
|
private void ToggleButton_Unchecked(object sender, RoutedEventArgs e)
|
|
{
|
|
Bearbeitungsmodus = false;
|
|
}
|
|
|
|
private void TreeView_MouseDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (e.ChangedButton == MouseButton.Left && Bearbeitungsmodus)
|
|
{
|
|
_lastMouseDown = e.GetPosition(TreeView);
|
|
}
|
|
}
|
|
private void TreeView_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (e.LeftButton == MouseButtonState.Pressed && Bearbeitungsmodus)
|
|
{
|
|
Point currentPosition = e.GetPosition(TreeView);
|
|
|
|
if ((Math.Abs(currentPosition.X - _lastMouseDown.X) > 10.0) ||
|
|
(Math.Abs(currentPosition.Y - _lastMouseDown.Y) > 10.0))
|
|
{
|
|
_draggedItem = (SupportConceptGoalTreeItem)TreeView.SelectedItem;
|
|
if (_draggedItem != null)
|
|
{
|
|
DragDropEffects finalDropEffect = DragDrop.DoDragDrop(TreeView, _SelectedGoalTreeNode, DragDropEffects.Move);
|
|
//Checking target is not null and item is
|
|
//dragging(moving)
|
|
if ((finalDropEffect == DragDropEffects.Move) && (_parent != null) && _parent != _draggedItem)
|
|
{
|
|
if (ContainsItem(_draggedItem, _parent))
|
|
MessageBox.Show("Kopieren in tiefere Ziele/Maßnamhen nicht möglich!");
|
|
else
|
|
MoveTreeItem(_draggedItem, _parent);
|
|
|
|
//var origin_parent = _draggedItem.ParentGoal as SupportConceptGoalTreeItem;
|
|
//var parent = _parent;
|
|
//var child = _draggedItem;
|
|
|
|
//origin_parent.Items.Remove(child);
|
|
//child.GoalEntryVM.ParentEntry = parent.GoalEntryDC ?? parent.GoalEntryVM.CommitToDataContract();
|
|
//parent.Items.Add(_draggedItem);
|
|
//parent.IsExpanded = true;
|
|
//TreeView.RefreshUI();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
private void TreeView_PreviewDragOver(object sender, DragEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
Point currentPosition = e.GetPosition(TreeView);
|
|
|
|
if ((Math.Abs(currentPosition.X - _lastMouseDown.X) > 0.0) ||
|
|
(Math.Abs(currentPosition.Y - _lastMouseDown.Y) > 0.0))
|
|
{
|
|
// Verify that this is a valid drop and then store the drop target
|
|
var item = GetNearestContainer(e.OriginalSource as UIElement);
|
|
if (CheckDropTarget(_draggedItem, item))
|
|
{
|
|
e.Effects = DragDropEffects.Move;
|
|
}
|
|
else
|
|
{
|
|
e.Effects = DragDropEffects.None;
|
|
}
|
|
}
|
|
e.Handled = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
}
|
|
private void TreeView_PreviewDrop(object sender, DragEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
e.Effects = DragDropEffects.None;
|
|
e.Handled = true;
|
|
|
|
// Verify that this is a valid drop and then store the drop target
|
|
var target = GetNearestContainer(e.OriginalSource as UIElement);
|
|
if (target != null && _draggedItem != null)
|
|
{
|
|
_parent = target;
|
|
e.Effects = DragDropEffects.Move;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
public List<ValueListEntryDC> GetAllChildren(SupportConceptGoalTreeItem treeItem, SupportConceptGoalDC dcItem)
|
|
{
|
|
List<ValueListEntryDC> returnThis = new List<ValueListEntryDC>();
|
|
|
|
if (dcItem == null)
|
|
{
|
|
returnThis.Add(treeItem.GoalEntryDC);
|
|
|
|
if (treeItem.Children.Count > 0)
|
|
{
|
|
foreach (var child in treeItem.Children)
|
|
{
|
|
returnThis.AddRange(GetAllChildren(null, child));
|
|
}
|
|
}
|
|
}
|
|
else if (treeItem == null)
|
|
{
|
|
returnThis.Add(dcItem.GoalEntryDC);
|
|
|
|
if (dcItem.Children.Count > 0)
|
|
{
|
|
foreach (var child in dcItem.Children)
|
|
{
|
|
returnThis.AddRange(GetAllChildren(null, child));
|
|
}
|
|
}
|
|
}
|
|
|
|
return returnThis;
|
|
}
|
|
protected override void Save()
|
|
{
|
|
var lToDos = new List<Action<IValueListService>>();
|
|
|
|
if (ViewModel.ChangedCount > 0)
|
|
{
|
|
lToDos.Add(s => s.UpdateValueListEntries(ViewModel.CommitChanged()));
|
|
}
|
|
|
|
if (ViewModel.AddedCount > 0)
|
|
{
|
|
var neueVMs = ViewModel.VMList.Where(w => w.IsNew).ToList();
|
|
|
|
_TreeViewItemsList = new List<SupportConceptGoalTreeItem>();
|
|
GetAllTreeViewItems();
|
|
|
|
var obersteZiele = neueVMs.Where(w => w.IsNew && (w.ParentEntry != null && w.ParentEntry.ValueListEntryOid != null) || w.ParentEntry == null);
|
|
|
|
foreach (var ziel in obersteZiele)
|
|
{
|
|
var ve = _TreeViewItemsList.FirstOrDefault(f => f.GoalEntryVM != null && f.GoalEntryVM.Equals(ziel));
|
|
if (ve != null)
|
|
{
|
|
GoalService.RecursiveSynchronousValueListEntrySave(ve); // Hier passiert bei Komponente E ein Fehler
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ViewModel.RemovedCount > 0)
|
|
{
|
|
var entfernte = _Children2Delete.Where(w => w.ValueListEntryOid != null).ToList();
|
|
var entfernteDic = entfernte.ToDictionary(k => k.ValueListEntryOid.Value, v => v.ValueListEntryVersion.Value);
|
|
entfernteDic.AddAndIgnoreDuplicates(ViewModel.GetRemoved().ToDictionary(dc => dc.ValueListEntryOid.Value, dc => dc.ValueListEntryVersion.Value));
|
|
|
|
lToDos.Add(s => s.DeactivateValueListEntries(entfernteDic));
|
|
}
|
|
|
|
ServiceFacade.DoMultipleValueListServicesAsync(lToDos, ReloadViewModel);
|
|
|
|
Cache.GetInstance().ClearAllValueListEntries();
|
|
}
|
|
private static void EditTreeItem(ValueListEntryVM valueListEntry)
|
|
{
|
|
if (valueListEntry == null) return;
|
|
if (valueListEntry.IsNew)
|
|
{
|
|
valueListEntry.CommitToDataContract();
|
|
}
|
|
var control = new ValueListEntryEditControl(valueListEntry, null);
|
|
var beWoWindow = new BeWoWindow();
|
|
|
|
control.CancelButtonClicked += () =>
|
|
{
|
|
if (control.ValueListEntry.IsDirty)
|
|
{
|
|
if (MessageBox.Show("Möchten Sie die Änderung verwerfen?", "Änderungen vorhanden", MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
|
|
return;
|
|
control.ResetValueListEntry();
|
|
}
|
|
beWoWindow.Close();
|
|
};
|
|
|
|
control.SaveButtonClicked += () => beWoWindow.Close();
|
|
|
|
beWoWindow.Height = 200;
|
|
beWoWindow.Width = 500;
|
|
beWoWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
|
|
beWoWindow.GroupBoxContent = control;
|
|
beWoWindow.Owner = BeWoApp.CurrentBeWo.MainWindow;
|
|
beWoWindow.rootGroupBox.Header = "Bearbeiten";
|
|
beWoWindow.ShowDialog();
|
|
}
|
|
private static void EditItem(TreeView tv, TreeViewItem tvi, object item, bool isNoticeTextBox = false)
|
|
{
|
|
if (item != null)
|
|
{
|
|
var treeItem = tvi;
|
|
if (treeItem == null && tv != null)
|
|
{
|
|
treeItem = tv.ItemContainerGenerator.ContainerFromItem(item) as TreeViewItem;
|
|
}
|
|
|
|
if (treeItem != null)
|
|
{
|
|
var textBox = BeWoWpfUtils.FindItem<TextBox>(treeItem, isNoticeTextBox ? 1 : 0);
|
|
|
|
if (textBox == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
textBox.IsReadOnly = false;
|
|
textBox.Padding = new Thickness(1, 1, 1, 1);
|
|
textBox.BorderThickness = new Thickness(1);
|
|
textBox.Background = Brushes.White;
|
|
textBox.Tag = tv.SelectedItem;
|
|
textBox.Focus();
|
|
textBox.SelectAll();
|
|
}
|
|
}
|
|
}
|
|
private static void UpdateSelectedTreeItemText(TextBoxBase textBox)
|
|
{
|
|
if (!textBox.IsReadOnly)
|
|
{
|
|
textBox.Background = Brushes.Transparent;
|
|
textBox.IsReadOnly = true;
|
|
textBox.BorderThickness = new Thickness(0);
|
|
textBox.Padding = new Thickness(1, 3, 1, 3);
|
|
}
|
|
}
|
|
private static SupportConceptGoalTreeItem SearchGoalTreeItem(SupportConceptGoalTreeItem supportConceptGoalTreeItem,
|
|
string description, string abbreviation, string notice)
|
|
{
|
|
if (supportConceptGoalTreeItem?.GoalEntryVM == null) return null;
|
|
|
|
if ((supportConceptGoalTreeItem.GoalEntryVM.Description ?? "") == (description ?? "") &&
|
|
(supportConceptGoalTreeItem.GoalEntryVM.Abbreviation ?? "") == (abbreviation ?? "") &&
|
|
(supportConceptGoalTreeItem.GoalEntryVM.Notice ?? "") == (notice ?? ""))
|
|
return supportConceptGoalTreeItem;
|
|
|
|
if (supportConceptGoalTreeItem.Items == null) return null;
|
|
|
|
foreach (var goal in supportConceptGoalTreeItem.Items)
|
|
{
|
|
var foundedGoal = SearchGoalTreeItem(goal, description, abbreviation, notice);
|
|
if (foundedGoal != null)
|
|
return foundedGoal;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void ReloadViewModel()
|
|
{
|
|
VMFactory.CreateGoalCategoryVMAsync(vm => this.Dispatch(() =>
|
|
{
|
|
ViewModel = vm;
|
|
}));
|
|
}
|
|
private void InitGoalCategoriesTreeView()
|
|
{
|
|
var categoriesWithParent = new List<SupportConceptGoalTreeItem>();
|
|
var test = ViewModel.VMList.ToList();
|
|
var goalList = GoalService.GetZieleMassnahmenTree(test, false);
|
|
var iGoalList = new ObservableSortCollection<SupportConceptGoalTreeItem>();
|
|
var dictOid2TreeItem = new Dictionary<long, SupportConceptGoalTreeItem>();
|
|
|
|
foreach (var category in goalList)
|
|
{
|
|
var item = new SupportConceptGoalTreeItem
|
|
{
|
|
GoalEntryDC = category.GoalEntryDC,
|
|
GoalEntryVM = ViewModel.VMList.FirstOrDefault(f => f.DataContract.ValueListEntryOid.Value == category.GoalEntryDC.ValueListEntryOid.Value),
|
|
IsExpanded = true,
|
|
ParentGoal = category.ParentGoal
|
|
};
|
|
if (item.GoalEntryDC.ParentOid == null)
|
|
{
|
|
iGoalList.Add(item);
|
|
}
|
|
else
|
|
{
|
|
categoriesWithParent.Add(item);
|
|
}
|
|
|
|
dictOid2TreeItem.Add(category.GoalEntryDC.ValueListEntryOid.Value, item);
|
|
}
|
|
|
|
foreach (var category in categoriesWithParent)
|
|
{
|
|
if (category.GoalEntryDC.ParentOid == null || category.GoalEntryDC.ValueListEntryOid == null)
|
|
continue;
|
|
|
|
if (dictOid2TreeItem.ContainsKey(category.GoalEntryDC.ParentOid.Value))
|
|
{
|
|
var parent = dictOid2TreeItem[category.GoalEntryDC.ParentOid.Value];
|
|
|
|
parent.Items.Add(dictOid2TreeItem[category.GoalEntryDC.ValueListEntryOid.Value]);
|
|
category.ParentGoal = parent;
|
|
}
|
|
}
|
|
|
|
var categoriesWithParents = dictOid2TreeItem.Values.Where(w => w.GoalEntryDC.ParentOid != null).ToList();
|
|
foreach (var goalCategory in categoriesWithParents)
|
|
{
|
|
if (dictOid2TreeItem.ContainsKey(goalCategory.GoalEntryDC.ParentOid.Value))
|
|
{
|
|
dictOid2TreeItem[goalCategory.GoalEntryDC.ParentOid.Value].Children.Add(goalCategory);
|
|
}
|
|
}
|
|
|
|
foreach (var goal in ViewModel.VMList.Where(w => w.Type.Equals(ValueListEntryType.SupportConceptGoalType)))
|
|
{
|
|
|
|
var item = new SupportConceptGoalTreeItem { GoalEntryVM = goal };
|
|
|
|
if (goal.ParentEntry == null || !goal.ParentEntry.ValueListEntryOid.HasValue || !dictOid2TreeItem.ContainsKey(goal.ParentEntry.ValueListEntryOid.Value))
|
|
{
|
|
iGoalList.Add(item);
|
|
}
|
|
else
|
|
{
|
|
var parent = dictOid2TreeItem[goal.ParentEntry.ValueListEntryOid.Value];
|
|
parent.Items.Add(item);
|
|
item.ParentGoal = parent;
|
|
}
|
|
}
|
|
|
|
GoalTree = iGoalList;
|
|
}
|
|
private void TraverseCollection(SupportConceptGoalTreeItem item)
|
|
{
|
|
var result = new List<ValueListEntryDC> { item.GoalEntryDC ?? item.GoalEntryVM.CommitToDataContract() };
|
|
|
|
foreach (var child in item.Items)
|
|
{
|
|
TraverseCollection(child);
|
|
}
|
|
|
|
_Children2Delete.AddRange(result);
|
|
}
|
|
private void GetAllTreeViewItems()
|
|
{
|
|
foreach (var parent in GoalTree)
|
|
{
|
|
TraverseTreeViewItem(parent);
|
|
}
|
|
}
|
|
private void TraverseTreeViewItem(SupportConceptGoalTreeItem item)
|
|
{
|
|
_TreeViewItemsList.Add(item);
|
|
foreach (var child in item.Items)
|
|
{
|
|
TraverseTreeViewItem(child);
|
|
}
|
|
}
|
|
private void ImportIcf(SupportConceptGoalDC goal)
|
|
{
|
|
if (goal == null) return;
|
|
|
|
goal.Children?.ForEach(ImportIcf);
|
|
|
|
if (goal.IsChecked)
|
|
AddIcf(goal);
|
|
}
|
|
private SupportConceptGoalTreeItem AddIcf(SupportConceptGoalDC goal)
|
|
{
|
|
if (goal == null) return null;
|
|
|
|
// Schaut, ob das Child bereits existiert
|
|
var similarGoal = GoalTree.FirstOrDefault(x => SearchGoalTreeItem(x, goal.GoalEntryDC.TypeDescription, goal.GoalEntryDC.Abbreviation, goal.GoalEntryDC.Notice) != null);
|
|
if (similarGoal != null)
|
|
return similarGoal;
|
|
|
|
// Schaut, ob das Goal ein Parent hat
|
|
if (goal.ParentGoal == null)
|
|
{
|
|
var treeItem = AddTreeItem(null, ValueListEntryType.SupportConceptGoalCategoryType,
|
|
goal.GoalEntryDC.TypeDescription, goal.GoalEntryDC.Abbreviation, goal.GoalEntryDC.Notice);
|
|
|
|
GoalTree.Add(treeItem);
|
|
|
|
GoalTree.Sort((x, y) => x.GoalEntryVM?.DisplayName?.CompareTo(y.GoalEntryVM?.DisplayName) ?? string.Compare(string.Empty, y.GoalEntryVM?.DisplayName, StringComparison.Ordinal));
|
|
|
|
return treeItem;
|
|
}
|
|
|
|
// Schaut, ob das ParentGoal bereits existiert
|
|
foreach (var goalTreeItem in GoalTree)
|
|
{
|
|
var similarParentGoal = SearchGoalTreeItem(goalTreeItem, goal.ParentGoal.GoalEntryDC.TypeDescription, goal.ParentGoal.GoalEntryDC.Abbreviation, goal.ParentGoal.GoalEntryDC.Notice);
|
|
if (similarParentGoal == null)
|
|
continue;
|
|
return AddTreeItem(similarParentGoal, ValueListEntryType.SupportConceptGoalCategoryType, goal.GoalEntryDC.TypeDescription, goal.GoalEntryDC.Abbreviation, goal.GoalEntryDC.Notice);
|
|
}
|
|
|
|
// Fügt den Parent hinzu
|
|
var parent = AddIcf(goal.ParentGoal);
|
|
return AddTreeItem(parent, ValueListEntryType.SupportConceptGoalCategoryType,
|
|
goal.GoalEntryDC.TypeDescription, goal.GoalEntryDC.Abbreviation, goal.GoalEntryDC.Notice);
|
|
}
|
|
|
|
public void AddTreeItemWithControl(SupportConceptGoalTreeItem parent, ValueListEntryType valueListEntryType, string viewHeader)
|
|
{
|
|
var control = new ValueListEntryEditControl(new ValueListEntryVM(new ValueListEntryDC()), null);
|
|
|
|
var beWoWindow = new BeWoWindow();
|
|
|
|
control.CancelButtonClicked += () =>
|
|
{
|
|
if (control.ValueListEntry.IsDirty)
|
|
{
|
|
if (MessageBox.Show("Möchten Sie die Änderung verwerfen?", "Änderungen vorhanden", MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
|
|
return;
|
|
control.ResetValueListEntry();
|
|
}
|
|
beWoWindow.Close();
|
|
};
|
|
|
|
control.SaveButtonClicked += () =>
|
|
{
|
|
var vm = control.ValueListEntry;
|
|
AddTreeItem(parent, valueListEntryType, vm.Description, vm.Abbreviation, vm.Notice);
|
|
beWoWindow.Close();
|
|
};
|
|
|
|
beWoWindow.Height = 200;
|
|
beWoWindow.Width = 500;
|
|
beWoWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
|
|
beWoWindow.GroupBoxContent = control;
|
|
beWoWindow.Owner = BeWoApp.CurrentBeWo.MainWindow;
|
|
beWoWindow.rootGroupBox.Header = viewHeader;
|
|
beWoWindow.ShowDialog();
|
|
}
|
|
public SupportConceptGoalTreeItem AddTreeItem(SupportConceptGoalTreeItem parent, ValueListEntryType valueListEntryType, string description, string abbreviation, string notice)
|
|
{
|
|
if (!valueListEntryType.HasFlag(ValueListEntryType.SupportConceptGoalCategoryType) &&
|
|
!valueListEntryType.HasFlag(ValueListEntryType.SupportConceptGoalType))
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
var vm = ViewModel.NewVM;
|
|
vm.Type = valueListEntryType;
|
|
vm.Description = description;
|
|
vm.Abbreviation = abbreviation;
|
|
vm.Notice = notice;
|
|
|
|
var newItem = new SupportConceptGoalTreeItem
|
|
{
|
|
GoalEntryVM = vm,
|
|
GoalEntryDC = vm.CommitToDataContract(),
|
|
ParentGoal = parent
|
|
};
|
|
|
|
ViewModel.AddNewVMToList();
|
|
|
|
if (parent == null) return newItem;
|
|
|
|
vm.ParentEntry = parent.GoalEntryDC ?? parent.GoalEntryVM.CommitToDataContract();
|
|
parent.GoalEntryVM = parent.GoalEntryVM;
|
|
parent.Items.Add(newItem);
|
|
parent.IsExpanded = true;
|
|
|
|
return newItem;
|
|
}
|
|
internal void DeleteIndividualGoal(SupportConceptGoalTreeItem selectedItem)
|
|
{
|
|
_Children2Delete = new List<ValueListEntryDC>();
|
|
TraverseCollection(selectedItem);
|
|
|
|
var parent = selectedItem.ParentGoal as SupportConceptGoalTreeItem;
|
|
if (parent != null && parent.Items != null)
|
|
parent.Items.Remove(selectedItem);
|
|
else
|
|
GoalTree.Remove(selectedItem);
|
|
|
|
ViewModel.VMList.Remove(selectedItem.GoalEntryVM);
|
|
}
|
|
private void CopyTreeItem(SupportConceptGoalTreeItem parent, SupportConceptGoalTreeItem source, bool force_deep_copy)
|
|
{
|
|
if (source == null || parent == null)
|
|
throw new NotImplementedException("#43298467891364987");
|
|
|
|
var wm = source.GoalEntryVM;
|
|
var node = AddTreeItem(parent, wm.Type, wm.Description, wm.Abbreviation, wm.Notice);
|
|
|
|
if (_CopyType == MassnahmenTreeCopyType.Subtree || force_deep_copy)
|
|
{
|
|
foreach (var child in source.Items)
|
|
{
|
|
CopyTreeItem(node, child, force_deep_copy);
|
|
}
|
|
}
|
|
}
|
|
private void MoveTreeItem(SupportConceptGoalTreeItem child, SupportConceptGoalTreeItem parent)
|
|
{
|
|
CopyTreeItem(parent, child, true);
|
|
DeleteIndividualGoal(child);
|
|
}
|
|
|
|
private SupportConceptGoalTreeItem GetNearestContainer(UIElement element)
|
|
{
|
|
TreeViewItem container = element as TreeViewItem;
|
|
while ((container == null) && (element != null))
|
|
{
|
|
element = VisualTreeHelper.GetParent(element) as UIElement;
|
|
container = element as TreeViewItem;
|
|
}
|
|
return container?.DataContext as SupportConceptGoalTreeItem;
|
|
}
|
|
private bool CheckDropTarget(SupportConceptGoalTreeItem _sourceItem, SupportConceptGoalTreeItem _targetItem)
|
|
{
|
|
if (_sourceItem == null || _targetItem == null)
|
|
return false;
|
|
|
|
//Check whether the target item is meeting your condition
|
|
|
|
var source = _sourceItem as SupportConceptGoalTreeItem;
|
|
var target = _targetItem as SupportConceptGoalTreeItem;
|
|
|
|
bool _isEqual = false;
|
|
// Unterschiedlicher Parent
|
|
|
|
if (!IstGleichesZiel(source.GoalEntryVM, target.GoalEntryVM))
|
|
{
|
|
_isEqual = true;
|
|
}
|
|
|
|
//if (source.GoalEntryVM.ParentEntry.ValueListEntryOid.Value != target.GoalEntryDC.ValueListEntryOid.Value)
|
|
//{
|
|
// // Nicht eigener
|
|
// if (!IstGleichesZiel(source.GoalEntryVM, target.GoalEntryVM))
|
|
// {
|
|
// _isEqual = true;
|
|
// }
|
|
//}
|
|
return _isEqual;
|
|
}
|
|
private bool IstGleichesZiel(ValueListEntryVM ziel1, ValueListEntryVM ziel2)
|
|
{
|
|
if (ziel1.DataContract.ValueListEntryOid.HasValue && ziel2.DataContract.ValueListEntryOid.HasValue)
|
|
{
|
|
return ziel1.DataContract.ValueListEntryOid.Value == ziel2.DataContract.ValueListEntryOid.Value;
|
|
}
|
|
else if (!ziel1.DataContract.ValueListEntryOid.HasValue && !ziel2.DataContract.ValueListEntryOid.HasValue)
|
|
{
|
|
if (ziel1.ParentEntry != null && ziel2.ParentEntry != null && ziel1.ParentEntry.Equals(ziel1.ParentEntry))
|
|
{
|
|
bool test = ziel1.Equals(ziel2);
|
|
return ziel1.Description == ziel2.Description;
|
|
}
|
|
else if (ziel1.ParentEntry == null && ziel2.ParentEntry == null)
|
|
{
|
|
return ziel1.Description == ziel2.Description;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
private bool ContainsItem(SupportConceptGoalDC root, SupportConceptGoalDC item)
|
|
{
|
|
if (root == item)
|
|
return true;
|
|
|
|
if (root.Children is object && root.Children.Any())
|
|
foreach (var child in root.Children)
|
|
{
|
|
if (ContainsItem(child, item))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void TreeView_DragEnter(object sender, DragEventArgs e)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
public class ValueListEntryTypeToFontWeightConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
var val = (bool)value;
|
|
|
|
return val ? FontWeights.Normal : FontWeights.Bold;
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
}
|