507 lines
19 KiB
C#
507 lines
19 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Controls.Primitives;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using BeWo.Core;
|
|
using BeWo.ViewModel;
|
|
|
|
using BS.Shared;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.ClientPartials;
|
|
using BS.Shared.Extensions;
|
|
|
|
namespace BeWo.View.Detail
|
|
{
|
|
public partial class SupportConceptGoalView : BeWoView
|
|
{
|
|
private SupportConceptVM _ViewModel;
|
|
|
|
private TreeViewItem _SelectedGoalTreeNode;
|
|
|
|
private ObservableCollection<SupportConceptGoalTreeItem> _SelectedGoals;
|
|
|
|
public SupportConceptGoalView(SupportConceptVM pViewModel)
|
|
{
|
|
this.InitializeComponent();
|
|
|
|
SelectedGoals = GetSelectedGoalTree(pViewModel);
|
|
|
|
treeview_Goals.ItemsSource = SelectedGoals;
|
|
|
|
this.ViewModel = pViewModel;
|
|
}
|
|
|
|
private ObservableCollection<SupportConceptGoalTreeItem> GetSelectedGoalTree(SupportConceptVM pViewModel)
|
|
{
|
|
var goals = GetSelectedGoals(pViewModel);
|
|
var copyList = new List<SupportConceptGoalTreeItem>();
|
|
foreach (var item in goals)
|
|
{
|
|
SupportConceptGoalTreeItem copy = CreateCopy(item);
|
|
copy.IsExpanded = true;
|
|
copyList.Add(copy);
|
|
}
|
|
|
|
ObservableCollection<SupportConceptGoalTreeItem> tree = CreateTree(copyList, pViewModel.CombinedGoalTree);
|
|
|
|
return tree;
|
|
}
|
|
|
|
public ObservableCollection<SupportConceptGoalTreeItem> SelectedGoals
|
|
{
|
|
get { return _SelectedGoals; }
|
|
set { _SelectedGoals = value; }
|
|
}
|
|
|
|
private ObservableCollection<SupportConceptGoalTreeItem> CreateTree(List<SupportConceptGoalTreeItem> copyList, ObservableCollection<SupportConceptGoalTreeItem> combinedGoalTree)
|
|
{
|
|
var tree = new ObservableCollection<SupportConceptGoalTreeItem>();
|
|
Dictionary<long, SupportConceptGoalTreeItem> totalOid2GoalDict = CreateGoalDictionary(combinedGoalTree);
|
|
Dictionary<long, SupportConceptGoalTreeItem> resultTreeOid2GoalDict = new Dictionary<long, SupportConceptGoalTreeItem>();
|
|
|
|
foreach (var goal in copyList)
|
|
{
|
|
AddParentToTree(tree, goal, totalOid2GoalDict, resultTreeOid2GoalDict);
|
|
}
|
|
|
|
return tree;
|
|
}
|
|
|
|
private void AddParentToTree(ObservableCollection<SupportConceptGoalTreeItem> tree, SupportConceptGoalTreeItem goal, Dictionary<long, SupportConceptGoalTreeItem> totalOid2GoalDict, Dictionary<long, SupportConceptGoalTreeItem> resultTreeOid2GoalDict)
|
|
{
|
|
if (goal.GoalEntryDC.ParentOid.HasValue)
|
|
{
|
|
if (totalOid2GoalDict.ContainsKey(goal.GoalEntryDC.ParentOid.Value))
|
|
{
|
|
SupportConceptGoalTreeItem parent = null;
|
|
if (resultTreeOid2GoalDict.ContainsKey(goal.GoalEntryDC.ParentOid.Value))
|
|
{
|
|
parent = resultTreeOid2GoalDict[goal.GoalEntryDC.ParentOid.Value];
|
|
}
|
|
else
|
|
{
|
|
parent = CreateCopy(totalOid2GoalDict[goal.GoalEntryDC.ParentOid.Value]);
|
|
parent.IsExpanded = true;
|
|
resultTreeOid2GoalDict.Add(goal.GoalEntryDC.ParentOid.Value, parent);
|
|
|
|
AddParentToTree(tree, parent, totalOid2GoalDict, resultTreeOid2GoalDict);
|
|
}
|
|
|
|
parent.Items.Add(goal);
|
|
parent.Children.Add(goal);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tree.Add(goal);
|
|
}
|
|
|
|
}
|
|
|
|
private Dictionary<long, SupportConceptGoalTreeItem> CreateGoalDictionary(ObservableCollection<SupportConceptGoalTreeItem> combinedGoalTree)
|
|
{
|
|
var dict = new Dictionary<long, SupportConceptGoalTreeItem>();
|
|
|
|
AddGoalsToDict(combinedGoalTree, dict);
|
|
|
|
return dict;
|
|
}
|
|
|
|
private void AddGoalsToDict(IList<SupportConceptGoalTreeItem> goals, Dictionary<long, SupportConceptGoalTreeItem> dict)
|
|
{
|
|
if (goals != null)
|
|
{
|
|
foreach (var item in goals)
|
|
{
|
|
if (!dict.ContainsKey(item.GoalEntryDC.ValueListEntryOid.Value))
|
|
{
|
|
dict.Add(item.GoalEntryDC.ValueListEntryOid.Value, item);
|
|
}
|
|
|
|
AddGoalsToDict(item.Items, dict);
|
|
}
|
|
}
|
|
}
|
|
|
|
private SupportConceptGoalTreeItem CreateCopy(SupportConceptGoalTreeItem item)
|
|
{
|
|
var copy = new SupportConceptGoalTreeItem();
|
|
var entryDc = new ValueListEntryDC();
|
|
entryDc.Abbreviation = item.GoalEntryDC.Abbreviation;
|
|
entryDc.Notice = item.GoalEntryDC.Notice;
|
|
entryDc.TypeDescription = item.GoalEntryDC.TypeDescription;
|
|
entryDc.ValueListEntryOid = item.GoalEntryDC.ValueListEntryOid;
|
|
entryDc.ValueListEntryVersion = item.GoalEntryDC.ValueListEntryVersion;
|
|
entryDc.Type = item.GoalEntryDC.Type;
|
|
entryDc.ParentOid = item.GoalEntryDC.ParentOid;
|
|
copy.GoalEntryDC = entryDc;
|
|
copy.GoalEntryVM = new ValueListEntryVM(entryDc);
|
|
|
|
return copy;
|
|
}
|
|
|
|
|
|
private ObservableCollection<SupportConceptGoalTreeItem> GetSelectedGoals(SupportConceptVM pViewModel)
|
|
{
|
|
var list = new ObservableCollection<SupportConceptGoalTreeItem>();
|
|
|
|
foreach (var item in pViewModel.CombinedGoalTree)
|
|
{
|
|
IterateThroughSelectedGoalsAndMassnahmen(item, list);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private void IterateThroughSelectedGoalsAndMassnahmen(SupportConceptGoalTreeItem item, ObservableCollection<SupportConceptGoalTreeItem> list)
|
|
{
|
|
if (item.IsChecked || (item.Items.Count == 0 && (item.GoalType == ValueListEntryType.SupportConceptIndividualGoalCategoryType || item.GoalType == ValueListEntryType.SupportConceptIndividualGoalType)))
|
|
{
|
|
list.Add(item);
|
|
}
|
|
|
|
foreach (var child in item.Items)
|
|
{
|
|
IterateThroughSelectedGoalsAndMassnahmen(child, list);
|
|
}
|
|
}
|
|
|
|
public override bool IsDirty
|
|
{
|
|
get
|
|
{
|
|
return this.ViewModel != null ? this.ViewModel.IsDirty : false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public SupportConceptVM ViewModel
|
|
{
|
|
get
|
|
{
|
|
return this._ViewModel;
|
|
}
|
|
|
|
set
|
|
{
|
|
this._ViewModel = value;
|
|
this.RootGrid.DataContext = value;
|
|
}
|
|
}
|
|
|
|
|
|
private void button_AddGoals_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var control = new GoalImportControl(CreateGoalTreeCopy(ViewModel.CombinedGoalTree, SelectedGoals));
|
|
|
|
var beWoWindow = new BeWoWindow
|
|
{
|
|
rootGroupBox = { Header = "Ziele hinzufügen" },
|
|
Height = this.Height,
|
|
Width = this.Width,
|
|
MinWidth = 550,
|
|
WindowStartupLocation = WindowStartupLocation.CenterOwner,
|
|
GroupBoxContent = control,
|
|
Owner = BeWoApp.CurrentBeWo.MainWindow
|
|
};
|
|
|
|
control.ButtonImportClicked += () =>
|
|
{
|
|
ImportGoals(control.GetSelectedGoals());
|
|
beWoWindow.Close();
|
|
};
|
|
|
|
control.ButtonCancelClicked += () =>
|
|
{
|
|
beWoWindow.Close();
|
|
};
|
|
|
|
beWoWindow.ShowDialog();
|
|
}
|
|
|
|
private ObservableCollection<SupportConceptGoalTreeItem> CreateGoalTreeCopy(ObservableCollection<SupportConceptGoalTreeItem> totalGoalTree, ObservableCollection<SupportConceptGoalTreeItem> selectedGoals)
|
|
{
|
|
var selectedDict = CreateGoalDictionary(selectedGoals);
|
|
|
|
var listWithoutSelected = GetGoalsWithoutSelected(totalGoalTree, selectedDict);
|
|
|
|
var copyList = new List<SupportConceptGoalTreeItem>();
|
|
foreach (var item in listWithoutSelected.Where(i => i.Children == null || i.Children.Count == 0))
|
|
{
|
|
if (item.GoalType == ValueListEntryType.SupportConceptGoalCategoryType ||
|
|
item.GoalType == ValueListEntryType.SupportConceptGoalType)
|
|
{
|
|
SupportConceptGoalTreeItem copy = CreateCopy(item);
|
|
copy.IsExpanded = false;
|
|
copyList.Add(copy);
|
|
}
|
|
}
|
|
|
|
ObservableCollection<SupportConceptGoalTreeItem> tree = CreateTree(copyList, totalGoalTree);
|
|
|
|
return tree;
|
|
}
|
|
|
|
private ObservableCollection<SupportConceptGoalTreeItem> GetGoalsWithoutSelected(ObservableCollection<SupportConceptGoalTreeItem> totalGoalTree, Dictionary<long, SupportConceptGoalTreeItem> selectedDict)
|
|
{
|
|
var list = new ObservableCollection<SupportConceptGoalTreeItem>();
|
|
|
|
foreach (var item in totalGoalTree)
|
|
{
|
|
AddGoalsWithoutSelected(item, list, selectedDict);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private void AddGoalsWithoutSelected(SupportConceptGoalTreeItem item, ObservableCollection<SupportConceptGoalTreeItem> list, Dictionary<long, SupportConceptGoalTreeItem> selectedDict)
|
|
{
|
|
if (!selectedDict.ContainsKey(item.GoalEntryDC.ValueListEntryOid.Value))
|
|
{
|
|
list.Add(item);
|
|
}
|
|
|
|
foreach (var child in item.Items)
|
|
{
|
|
AddGoalsWithoutSelected(child, list, selectedDict);
|
|
}
|
|
}
|
|
|
|
private void ImportGoals(IList<SupportConceptGoalTreeItem> goals)
|
|
{
|
|
foreach (var goal in goals)
|
|
{
|
|
AddGoalToTree(goal, null);
|
|
}
|
|
}
|
|
|
|
|
|
private void AddGoalToTree(SupportConceptGoalTreeItem goal, SupportConceptGoalTreeItem child)
|
|
{
|
|
var copy = CreateCopy(goal);
|
|
copy.IsExpanded = true;
|
|
if (child != null)
|
|
{
|
|
copy.Items.Add(child);
|
|
}
|
|
|
|
var parentElement = GetExistingParent(copy);
|
|
|
|
if (parentElement == null)
|
|
{
|
|
parentElement = GetParentFromTotalTree(copy);
|
|
|
|
if (parentElement != null)
|
|
{
|
|
AddGoalToTree(parentElement, copy);
|
|
}
|
|
else
|
|
{
|
|
SelectedGoals.Add(copy);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int idx = 0;
|
|
foreach (var ei in parentElement.Items)
|
|
{
|
|
if (goal.DetailDescription.CompareTo(ei.DetailDescription) > 0)
|
|
{
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
parentElement.Items.Insert(idx, goal);
|
|
//parentElement.Items.Sort((a, b) => a.DetailDescription.CompareTo(b.DetailDescription));
|
|
}
|
|
ViewModel.ChangedGoals.Add(copy);
|
|
}
|
|
|
|
private SupportConceptGoalTreeItem GetExistingParent(SupportConceptGoalTreeItem copy)
|
|
{
|
|
return GetParentForGoal(SelectedGoals, copy);
|
|
}
|
|
|
|
private SupportConceptGoalTreeItem GetParentFromTotalTree(SupportConceptGoalTreeItem copy)
|
|
{
|
|
return GetParentForGoal(ViewModel.CombinedGoalTree, copy);
|
|
}
|
|
|
|
private SupportConceptGoalTreeItem GetParentForGoal(IList<SupportConceptGoalTreeItem> goals, SupportConceptGoalTreeItem copy)
|
|
{
|
|
SupportConceptGoalTreeItem found = null;
|
|
|
|
if (copy.GoalEntryDC.ParentOid.HasValue)
|
|
{
|
|
foreach (var goal in goals)
|
|
{
|
|
if (goal.GoalEntryDC.ValueListEntryOid == copy.GoalEntryDC.ParentOid)
|
|
{
|
|
return goal;
|
|
}
|
|
|
|
found = GetParentForGoal(goal.Items, copy);
|
|
|
|
if (found != null)
|
|
{
|
|
return found;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
|
|
private void button_aufklappenAllGoals_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
SwitchAllGoalTreeItems(true);
|
|
}
|
|
|
|
private void button_zuklappenAllGoals_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
SwitchAllGoalTreeItems(false);
|
|
}
|
|
|
|
private void SwitchAllGoalTreeItems(bool check)
|
|
{
|
|
Style stylee = new Style
|
|
{
|
|
TargetType = typeof(TreeViewItem)
|
|
};
|
|
|
|
stylee.Setters.Add(new Setter(TreeViewItem.IsExpandedProperty, check));
|
|
treeview_Goals.ItemContainerStyle = stylee;
|
|
}
|
|
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
private void TextBox_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.Key == Key.Return)
|
|
{
|
|
UpdateSelectedTreeItemText((TextBox)sender);
|
|
}
|
|
}
|
|
|
|
private void TextBox_LostFocus(object sender, RoutedEventArgs e)
|
|
{
|
|
UpdateSelectedTreeItemText((TextBox)sender);
|
|
}
|
|
|
|
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 void ContextMenuGoals_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if (!(e.OriginalSource is MenuItem twi)) return;
|
|
|
|
var selectedItem = treeview_Goals.SelectedItem as SupportConceptGoalTreeItem;
|
|
|
|
switch (twi.Header)
|
|
{
|
|
case "Neues individuelles Ziel":
|
|
if (_SelectedGoalTreeNode != null)
|
|
{
|
|
ViewModel.AddTreeItemWithControl(selectedItem, ValueListEntryType.SupportConceptIndividualGoalCategoryType, "Ziel hinzufügen");
|
|
}
|
|
break;
|
|
case "Neue individuelle Maßnahme":
|
|
if (_SelectedGoalTreeNode != null)
|
|
{
|
|
ViewModel.AddTreeItemWithControl(selectedItem, ValueListEntryType.SupportConceptIndividualGoalType, "Maßnahme hinzufügen");
|
|
}
|
|
break;
|
|
case "Löschen":
|
|
if (selectedItem != null)
|
|
{
|
|
var zielOderMassnahme = selectedItem.GoalEntryVM.Type == ValueListEntryType.SupportConceptGoalCategoryType || selectedItem.GoalEntryVM.Type == ValueListEntryType.SupportConceptIndividualGoalCategoryType ? "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)
|
|
{
|
|
ViewModel.DeleteIndividualGoal(selectedItem);
|
|
}
|
|
}
|
|
break;
|
|
case "Bearbeiten":
|
|
if (selectedItem != null)
|
|
ViewModel.EditTreeItem(selectedItem.GoalEntryVM);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void ContextMenuGoals_Opened(object sender, RoutedEventArgs e)
|
|
{
|
|
if (e.OriginalSource is ContextMenu)
|
|
{
|
|
var menu = e.OriginalSource as ContextMenu;
|
|
var goal = treeview_Goals.SelectedItem as SupportConceptGoalTreeItem;
|
|
|
|
foreach (var menuitem in menu.Items.OfType<MenuItem>().Select(item => item))
|
|
{
|
|
if (menuitem.Header.Equals("Bearbeiten"))
|
|
{
|
|
menuitem.IsEnabled = goal != null && (goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalCategoryType) || goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalType));
|
|
}
|
|
else if (menuitem.Header.Equals("Neues individuelles Ziel") || menuitem.Header.Equals("Neue individuelle Maßnahme"))
|
|
{
|
|
menuitem.IsEnabled = goal != null && (goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalCategoryType) || goal.GoalType.Equals(ValueListEntryType.SupportConceptGoalCategoryType));
|
|
}
|
|
else if (menuitem.Header.Equals("Löschen"))
|
|
{
|
|
menuitem.IsEnabled = goal != null && (goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalCategoryType) || goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalType));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void button_AddRating_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
ViewModel.Ratings.VMList.AddNew();
|
|
}
|
|
|
|
private void btn_deleteRating_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var vm = ((Button)sender).Tag as RatingVM;
|
|
|
|
ViewModel.Ratings.VMList.Remove(vm);
|
|
}
|
|
}
|
|
} |