1423 lines
60 KiB
C#
1423 lines
60 KiB
C#
|
|
using BeWo.View.Navigation.Filter;
|
|
using BS.Shared;
|
|
using BS.Shared.DataContracts;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Input;
|
|
using DevExpress.Xpf.Accordion;
|
|
using DevExpress.Mvvm.UI.Native;
|
|
using BeWo.ViewModel;
|
|
using DevExpress.XtraEditors;
|
|
using DevExpress.Xpf.Grid.TreeList;
|
|
using DevExpress.Xpf.Grid;
|
|
using DevExpress.XtraPrinting.Native;
|
|
using DevExpress.Utils;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Imaging;
|
|
using System.Data;
|
|
using BeWo.ServiceProxy;
|
|
using BeWo.Core;
|
|
using System.Windows.Forms;
|
|
using MessageBox = System.Windows.MessageBox;
|
|
using BS.Shared.Extensions;
|
|
using BS.Shared.Core;
|
|
using System.IO;
|
|
using System.Windows.Threading;
|
|
using System.Windows.Documents;
|
|
using System.Windows.Navigation;
|
|
using ContextMenu = System.Windows.Controls.ContextMenu;
|
|
using MenuItem = System.Windows.Controls.MenuItem;
|
|
using System.Windows.Controls.Primitives;
|
|
using TextBox = System.Windows.Controls.TextBox;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BeWo.View.Detail;
|
|
using System.Text;
|
|
|
|
namespace BeWo.View.Master
|
|
{
|
|
public partial class DokumenteView
|
|
{
|
|
private string _UploadFileName;
|
|
private string _NormalFileName = null;
|
|
private string _FileNotice = "";
|
|
private readonly long? _ObjectOid;
|
|
private readonly TableID _ObjectTid;
|
|
private TreeViewItem _SelectedTreeNode;
|
|
|
|
public DokumenteView()
|
|
{
|
|
InitializeComponent();
|
|
InitDocumentMenuItems();
|
|
InitTemplateMenuItems();
|
|
|
|
progressbar_upload.Visibility = Visibility.Collapsed;
|
|
text_progress.Visibility = Visibility.Collapsed;
|
|
}
|
|
|
|
public void InitDocumentMenuItems()
|
|
{
|
|
documents_treeview_control.BeginDataUpdate();
|
|
|
|
Dictionary<string, string> firstLevel = GetFirstLevelDictionaryForDocuments();
|
|
string[] iconNames = new string[] { "IDBadgeDisabled", "UserHomeMaleDisabled", "OfficeBulidingBlackDisabled", "AnonymousUserDisabled",
|
|
"UserBusinessMaleDisabled", "UserGroupBusinessDisabled", "UserBusinessMaleDisabled", "UserGroupBusinessDisabled" };
|
|
TableID[] tables = new TableID[] {TableID.SupportConcept, TableID.Customer, TableID.Organisation, TableID.Person, TableID.Employee,
|
|
TableID.Team, TableID.ApplicationUser, TableID.UserGroup};
|
|
int counter = 1;
|
|
foreach (var pair in firstLevel)
|
|
{
|
|
TreeListNode node = new TreeListNode();
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = counter,
|
|
ParentOid = null,
|
|
Name = pair.Value,
|
|
Table = tables[counter - 1]
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
node.Content = vm;
|
|
DocumentsTreeView.Nodes.Add(node);
|
|
node.IsExpandButtonVisible = DefaultBoolean.True;
|
|
node.Tag = false;
|
|
node.Image = LoadImage(iconNames[counter - 1]);
|
|
counter++;
|
|
}
|
|
documents_treeview_control.EndDataUpdate();
|
|
}
|
|
|
|
private Dictionary<string, string> GetFirstLevelDictionaryForDocuments()
|
|
{
|
|
Dictionary<string, string> firstLevel = new Dictionary<string, string>();
|
|
|
|
firstLevel.Add("supportConcepts", "Hilfepläne");
|
|
firstLevel.Add("customers", "Klienten");
|
|
firstLevel.Add("organisations", "Organisationen");
|
|
firstLevel.Add("people", "Personen");
|
|
firstLevel.Add("employee", "Mitarbeiter");
|
|
firstLevel.Add("teams", "Teams");
|
|
firstLevel.Add("users", "Benutzer");
|
|
firstLevel.Add("usergroups", "Benutzergruppen");
|
|
|
|
return firstLevel;
|
|
}
|
|
|
|
private void treeListView_NodeExpanding(object sender, TreeListNodeAllowEventArgs e)
|
|
{
|
|
TreeListNode node = e.Node;
|
|
var vm = node.Content as DocumentTreeItemVM;
|
|
|
|
if (vm.ParentOid == null)
|
|
{
|
|
switch (vm.Name)
|
|
{
|
|
case "Hilfepläne": SupportConcepts_Expended(node); break;
|
|
case "Klienten": Customers_Expended(node); break;
|
|
case "Organisationen": Organisations_Expended(node); break;
|
|
case "Personen": People_Expended(node); break;
|
|
case "Mitarbeiter": Employee_Expended(node); break;
|
|
case "Teams": Teams_Expended(node); break;
|
|
case "Benutzer": Users_Expended(node); break;
|
|
case "Benutzergruppen": UserGroups_Expended(node); break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SubNode_Expended(node);
|
|
}
|
|
}
|
|
|
|
private void SubNode_Expended(TreeListNode node)
|
|
{
|
|
var parentNode = node.ParentNode;
|
|
var parentContent = parentNode.Content as DocumentTreeItemVM;
|
|
var childContent = node.Content as DocumentTreeItemVM;
|
|
|
|
List<BeWoFolderDC> folderDCs = new List<BeWoFolderDC>();
|
|
if (parentContent.DocTreeItemOid == 1 && parentContent.Name.Equals("Hilfepläne"))
|
|
{
|
|
//SupportConcept
|
|
folderDCs = VMFactory.CreateFolderList(TableID.SupportConcept, (long)childContent.DocTreeItemOid);
|
|
}
|
|
else if (parentContent.DocTreeItemOid == 2 && parentContent.Name.Equals("Klienten"))
|
|
{
|
|
//Customer
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Customer, (long)childContent.DocTreeItemOid);
|
|
}
|
|
else if (parentContent.DocTreeItemOid == 3 && parentContent.Name.Equals("Organisationen"))
|
|
{
|
|
//Organisation
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Organisation, (long)childContent.DocTreeItemOid);
|
|
}
|
|
else if (parentContent.DocTreeItemOid == 4 && parentContent.Name.Equals("Personen"))
|
|
{
|
|
//Person
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Person, (long)childContent.DocTreeItemOid);
|
|
}
|
|
else if (parentContent.DocTreeItemOid == 5 && parentContent.Name.Equals("Mitarbeiter"))
|
|
{
|
|
//Employee
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Employee, (long)childContent.DocTreeItemOid);
|
|
}
|
|
else if (parentContent.DocTreeItemOid == 6 && parentContent.Name.Equals("Teams"))
|
|
{
|
|
//Team
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Team, (long)childContent.DocTreeItemOid);
|
|
}
|
|
else if (parentContent.DocTreeItemOid == 7 && parentContent.Name.Equals("Benutzer"))
|
|
{
|
|
//User
|
|
folderDCs = VMFactory.CreateFolderList(TableID.ApplicationUser, (long)childContent.DocTreeItemOid);
|
|
}
|
|
else if (parentContent.DocTreeItemOid == 8 && parentContent.Name.Equals("Benutzergruppen"))
|
|
{
|
|
//UserGroup
|
|
folderDCs = VMFactory.CreateFolderList(TableID.UserGroup, (long)childContent.DocTreeItemOid);
|
|
}
|
|
|
|
GenerateFolderStructureForSelectedNode(node, folderDCs);
|
|
}
|
|
|
|
private void GenerateFolderStructureForSelectedNode(TreeListNode node, List<BeWoFolderDC> folderDCs)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
var content = node.Content as DocumentTreeItemVM;
|
|
|
|
foreach (var folder in folderDCs)
|
|
{
|
|
DocumentTreeItemDC folder_dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = folder.BeWoFolderOid,
|
|
ParentOid = content.DocTreeItemOid,
|
|
Name = folder.Name,
|
|
FilesInFolder = new List<FileAttachmentDC>(),
|
|
BeWoFolderDC = folder,
|
|
Table = content.DataContract.Table,
|
|
ObjectOid = content.DataContract.ObjectOid
|
|
};
|
|
if (folder.Files.Count != 0)
|
|
{
|
|
foreach (var file in folder.Files)
|
|
{
|
|
folder_dc.FilesInFolder.Add(file);
|
|
}
|
|
}
|
|
DocumentTreeItemVM folder_vm = new DocumentTreeItemVM(folder_dc);
|
|
TreeListNode newNode_folder = new TreeListNode()
|
|
{
|
|
Content = folder_vm,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadFolderImage()
|
|
};
|
|
folder_dc.Node = newNode_folder;
|
|
node.Nodes.Add(newNode_folder);
|
|
|
|
if (folder.SubFolders.Count != 0)
|
|
{
|
|
GenerateFolderStructureForSelectedNode(newNode_folder, folder.SubFolders);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//Universelle Methode zum sparen von Code
|
|
private void Node_Expended(TreeListNode node, string nodeName)
|
|
{
|
|
//switch (nodeName)
|
|
//{
|
|
// case "Hilfepläne": var liste = VMFactory.CreateSupportConceptList(); break;
|
|
|
|
//}
|
|
}
|
|
|
|
private void SupportConcepts_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Hilfepläne in eine Liste holen
|
|
var liste = VMFactory.CreateSupportConceptList();
|
|
|
|
if (liste.Count == 0)
|
|
{
|
|
MessageBox.Show("Sie verfügen nicht über die Benutzerrechte, die zum Anzeigen der Hilfepläne benötigt werden. " +
|
|
"\nWenden Sie sich an den administrierenden Mitarbeiter.", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
|
|
return;
|
|
}
|
|
|
|
//Liste durchlaufen und für jedes Elemement ein entsprechendes DocumentTreeItemDC/VM erstellen
|
|
List<DocumentTreeItemVM> docTreeItemVMs = new List<DocumentTreeItemVM>();
|
|
var parentNode = node.Content as DocumentTreeItemVM;
|
|
foreach (var item in liste)
|
|
{
|
|
string span = CustomizeDates(item.StartDate, item.EndDate);
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = item.SupportConceptOid,
|
|
ParentOid = parentNode.DocTreeItemOid,
|
|
Name = item.CustomerName + " " + span,
|
|
Table = TableID.SupportConcept,
|
|
ObjectOid = item.SupportConceptOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
docTreeItemVMs.Add(vm);
|
|
}
|
|
|
|
//VMs als neue Subnodes an DocumentsTreeView.Nodes hängen
|
|
foreach (var item in docTreeItemVMs)
|
|
{
|
|
TreeListNode newNode = new TreeListNode()
|
|
{
|
|
Content = item,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadImage("IDBadgeDisabled")
|
|
};
|
|
node.Nodes.Add(newNode);
|
|
}
|
|
}
|
|
}
|
|
private void Customers_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Klienten in eine Liste holen
|
|
var liste = VMFactory.CreateCustomerList();
|
|
|
|
if (liste.Count == 0)
|
|
{
|
|
MessageBox.Show("Sie verfügen nicht über die Benutzerrechte, die zum Anzeigen der Klienten benötigt werden. " +
|
|
"\nWenden Sie sich an den administrierenden Mitarbeiter.", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
|
|
return;
|
|
}
|
|
|
|
//Liste durchlaufen und für jedes Elemement ein entsprechendes DocumentTreeItemDC/VM erstellen
|
|
List<DocumentTreeItemVM> docTreeItemVMs = new List<DocumentTreeItemVM>();
|
|
var parentNode = node.Content as DocumentTreeItemVM;
|
|
foreach (var item in liste)
|
|
{
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = item.CustomerOid,
|
|
ParentOid = parentNode.DocTreeItemOid,
|
|
Name = item.LastNameFirstName,
|
|
Table = TableID.Customer,
|
|
ObjectOid = item.CustomerOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
docTreeItemVMs.Add(vm);
|
|
}
|
|
|
|
//VMs als neue Subnodes an DocumentsTreeView.Nodes hängen oder vorhandene sichtbar machen
|
|
foreach (var item in docTreeItemVMs)
|
|
{
|
|
TreeListNode newNode = new TreeListNode()
|
|
{
|
|
Content = item,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadImage("UserHomeMaleDisabled")
|
|
};
|
|
node.Nodes.Add(newNode);
|
|
}
|
|
}
|
|
}
|
|
private void Organisations_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Klienten in eine Liste holen
|
|
var liste = VMFactory.CreateOrganisationList();
|
|
|
|
if (liste.Count == 0)
|
|
{
|
|
MessageBox.Show("Sie verfügen nicht über die Benutzerrechte, die zum Anzeigen der Organisationen benötigt werden. " +
|
|
"\nWenden Sie sich an den administrierenden Mitarbeiter.", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
|
|
return;
|
|
}
|
|
|
|
//Liste durchlaufen und für jedes Elemement ein entsprechendes DocumentTreeItemDC/VM erstellen
|
|
List<DocumentTreeItemVM> docTreeItemVMs = new List<DocumentTreeItemVM>();
|
|
var parentNode = node.Content as DocumentTreeItemVM;
|
|
foreach (var item in liste)
|
|
{
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = item.OrganisationOid,
|
|
ParentOid = parentNode.DocTreeItemOid,
|
|
Name = item.Name,
|
|
Table = TableID.Organisation,
|
|
ObjectOid = item.OrganisationOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
docTreeItemVMs.Add(vm);
|
|
}
|
|
|
|
//VMs als neue Subnodes an DocumentsTreeView.Nodes hängen oder vorhandene sichtbar machen
|
|
foreach (var item in docTreeItemVMs)
|
|
{
|
|
TreeListNode newNode = new TreeListNode()
|
|
{
|
|
Content = item,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadImage("OfficeBulidingBlackDisabled")
|
|
};
|
|
node.Nodes.Add(newNode);
|
|
}
|
|
}
|
|
}
|
|
private void People_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Klienten in eine Liste holen
|
|
var liste = VMFactory.CreatePeopleList();
|
|
|
|
//Liste durchlaufen und für jedes Elemement ein entsprechendes DocumentTreeItemDC/VM erstellen
|
|
List<DocumentTreeItemVM> docTreeItemVMs = new List<DocumentTreeItemVM>();
|
|
var parentNode = node.Content as DocumentTreeItemVM;
|
|
foreach (var item in liste)
|
|
{
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = item.PersonOid,
|
|
ParentOid = parentNode.DocTreeItemOid,
|
|
Name = item.FullName,
|
|
Table = TableID.Person,
|
|
ObjectOid = item.PersonOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
docTreeItemVMs.Add(vm);
|
|
}
|
|
|
|
//VMs als neue Subnodes an DocumentsTreeView.Nodes hängen oder vorhandene sichtbar machen
|
|
foreach (var item in docTreeItemVMs)
|
|
{
|
|
TreeListNode newNode = new TreeListNode()
|
|
{
|
|
Content = item,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadImage("AnonymousUserDisabled")
|
|
};
|
|
node.Nodes.Add(newNode);
|
|
}
|
|
}
|
|
}
|
|
private void Employee_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Klienten in eine Liste holen
|
|
var liste = VMFactory.CreateEmployeeList();
|
|
|
|
//Liste durchlaufen und für jedes Elemement ein entsprechendes DocumentTreeItemDC/VM erstellen
|
|
List<DocumentTreeItemVM> docTreeItemVMs = new List<DocumentTreeItemVM>();
|
|
var parentNode = node.Content as DocumentTreeItemVM;
|
|
foreach (var item in liste)
|
|
{
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = item.EmployeeOid,
|
|
ParentOid = parentNode.DocTreeItemOid,
|
|
Name = item.LastName + ", " + item.FirstName,
|
|
Table = TableID.Employee,
|
|
ObjectOid = item.EmployeeOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
docTreeItemVMs.Add(vm);
|
|
}
|
|
|
|
//VMs als neue Subnodes an DocumentsTreeView.Nodes hängen oder vorhandene sichtbar machen
|
|
foreach (var item in docTreeItemVMs)
|
|
{
|
|
TreeListNode newNode = new TreeListNode()
|
|
{
|
|
Content = item,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadImage("UserBusinessMaleDisabled")
|
|
};
|
|
node.Nodes.Add(newNode);
|
|
}
|
|
}
|
|
}
|
|
private void Teams_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Hilfepläne in eine Liste holen
|
|
var liste = VMFactory.CreateTeamList();
|
|
|
|
|
|
//Liste durchlaufen und für jedes Elemement ein entsprechendes DocumentTreeItemDC/VM erstellen
|
|
List<DocumentTreeItemVM> docTreeItemVMs = new List<DocumentTreeItemVM>();
|
|
var parentNode = node.Content as DocumentTreeItemVM;
|
|
foreach (var item in liste)
|
|
{
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = item.TeamOid,
|
|
ParentOid = parentNode.DocTreeItemOid,
|
|
Name = item.Name,
|
|
Table = TableID.Team,
|
|
ObjectOid = item.TeamOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
docTreeItemVMs.Add(vm);
|
|
}
|
|
|
|
//VMs als neue Subnodes an DocumentsTreeView.Nodes hängen
|
|
foreach (var item in docTreeItemVMs)
|
|
{
|
|
TreeListNode newNode = new TreeListNode()
|
|
{
|
|
Content = item,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadImage("UserGroupBusinessDisabled")
|
|
};
|
|
node.Nodes.Add(newNode);
|
|
}
|
|
}
|
|
}
|
|
private void Users_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Hilfepläne in eine Liste holen
|
|
var liste = VMFactory.CreateUserList();
|
|
|
|
//Liste durchlaufen und für jedes Elemement ein entsprechendes DocumentTreeItemDC/VM erstellen
|
|
List<DocumentTreeItemVM> docTreeItemVMs = new List<DocumentTreeItemVM>();
|
|
var parentNode = node.Content as DocumentTreeItemVM;
|
|
foreach (var item in liste)
|
|
{
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = item.UserOid,
|
|
ParentOid = parentNode.DocTreeItemOid,
|
|
Name = item.LoginName,
|
|
Table = TableID.ApplicationUser,
|
|
ObjectOid = item.UserOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
docTreeItemVMs.Add(vm);
|
|
}
|
|
|
|
//VMs als neue Subnodes an DocumentsTreeView.Nodes hängen
|
|
foreach (var item in docTreeItemVMs)
|
|
{
|
|
TreeListNode newNode = new TreeListNode()
|
|
{
|
|
Content = item,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadImage("UserBusinessMaleDisabled")
|
|
};
|
|
node.Nodes.Add(newNode);
|
|
}
|
|
}
|
|
|
|
}
|
|
private void UserGroups_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Hilfepläne in eine Liste holen
|
|
var liste = VMFactory.CreateUserGroupList();
|
|
|
|
//Liste durchlaufen und für jedes Elemement ein entsprechendes DocumentTreeItemDC/VM erstellen
|
|
List<DocumentTreeItemVM> docTreeItemVMs = new List<DocumentTreeItemVM>();
|
|
var parentNode = node.Content as DocumentTreeItemVM;
|
|
foreach (var item in liste)
|
|
{
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = item.UserGroupOid,
|
|
ParentOid = parentNode.DocTreeItemOid,
|
|
Name = item.Name,
|
|
Table = TableID.UserGroup,
|
|
ObjectOid = item.UserGroupOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
docTreeItemVMs.Add(vm);
|
|
}
|
|
|
|
//VMs als neue Subnodes an DocumentsTreeView.Nodes hängen
|
|
foreach (var item in docTreeItemVMs)
|
|
{
|
|
TreeListNode newNode = new TreeListNode()
|
|
{
|
|
Content = item,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadImage("UserGroupBusinessDisabled")
|
|
};
|
|
node.Nodes.Add(newNode);
|
|
}
|
|
}
|
|
}
|
|
private string CustomizeDates(DateTime? startdate, DateTime? enddate)
|
|
{
|
|
string span = "";
|
|
string startday, endday, startmonth, endmonth;
|
|
|
|
startday = (startdate.Value.Day < 10) ? "0" + startdate.Value.Day : startdate.Value.Day.ToString();
|
|
endday = (enddate.Value.Day < 10) ? "0" + enddate.Value.Day : enddate.Value.Day.ToString();
|
|
startmonth = (startdate.Value.Month < 10) ? "0" + startdate.Value.Month : startdate.Value.Month.ToString();
|
|
endmonth = (enddate.Value.Month < 10) ? "0" + enddate.Value.Month : enddate.Value.Month.ToString();
|
|
|
|
span = "(" + startday + "." + startmonth + "." + startdate.Value.Year + " - " + endday + "." + endmonth + "." + enddate.Value.Year + ")";
|
|
|
|
return span;
|
|
}
|
|
private BitmapImage LoadImage(string imageName)
|
|
{
|
|
return new BitmapImage(new Uri("/Ressources/Icons/" + imageName + ".png", UriKind.Relative));
|
|
}
|
|
private BitmapImage LoadFolderImage()
|
|
{
|
|
return new BitmapImage(new Uri("/Ressources/Icons/Folder.png", UriKind.Relative));
|
|
}
|
|
|
|
private void ContextMenu_Opened(object sender, RoutedEventArgs e)
|
|
{
|
|
if (e.OriginalSource is ContextMenu)
|
|
{
|
|
ContextMenu menu = e.OriginalSource as ContextMenu;
|
|
|
|
DocumentTreeItemVM treeviewitem = this.documents_treeview_control.SelectedItem as DocumentTreeItemVM;
|
|
|
|
foreach (var item in menu.Items)
|
|
{
|
|
if (item is MenuItem)
|
|
{
|
|
MenuItem menuitem = item as MenuItem;
|
|
|
|
if (treeviewitem.DataContract.BeWoFolderDC != null)
|
|
{
|
|
if (treeviewitem.Name.Equals("Alle Ordner"))
|
|
{
|
|
if (menuitem.Header.Equals("Neu"))
|
|
menuitem.IsEnabled = true;
|
|
else
|
|
menuitem.IsEnabled = false;
|
|
}
|
|
else
|
|
{
|
|
menuitem.IsEnabled = true;
|
|
}
|
|
}
|
|
else
|
|
menuitem.IsEnabled = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ContextMenu_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if (e.OriginalSource is MenuItem)
|
|
{
|
|
var row = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
var twi = e.OriginalSource as MenuItem;
|
|
|
|
if (twi.Header.Equals("Neu"))
|
|
{
|
|
TreeListNode node = new TreeListNode();
|
|
node.IsExpandButtonVisible = DefaultBoolean.True;
|
|
node.Tag = false;
|
|
node.Image = LoadFolderImage();
|
|
|
|
BeWoFolderDC folderDC = new BeWoFolderDC()
|
|
{
|
|
Name = "Neuer Ordner",
|
|
ParentBeWoFolderOid = row.DataContract.BeWoFolderDC.BeWoFolderOid,
|
|
ObjectOid = row.DataContract.ObjectOid,
|
|
ObjectTid = row.DataContract.Table,
|
|
Files = new List<FileAttachmentDC>(),
|
|
SubFolders = new List<BeWoFolderDC>()
|
|
};
|
|
InsertFolder(folderDC);
|
|
|
|
row.DataContract.BeWoFolderDC.SubFolders.Add(folderDC);
|
|
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
Name = "Neuer Ordner",
|
|
DocTreeItemOid = folderDC.BeWoFolderOid,
|
|
ParentOid = row.DocTreeItemOid,
|
|
BeWoFolderDC = folderDC,
|
|
Table = row.DataContract.Table,
|
|
ObjectOid = row.DataContract.ObjectOid,
|
|
FilesInFolder = new List<FileAttachmentDC>(),
|
|
Node = node
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
dc.Node.Content = vm;
|
|
row.DataContract.Node.Nodes.Add(dc.Node);
|
|
}
|
|
else if (twi.Header.Equals("Umbenennen"))
|
|
{
|
|
this.EditSelected();
|
|
}
|
|
else if (twi.Header.Equals("Löschen"))
|
|
{
|
|
DeleteFolderWithAllSubfolders(row.DataContract.BeWoFolderDC);
|
|
}
|
|
}
|
|
}
|
|
private void EditSelected()
|
|
{
|
|
DocumentsTreeView.AllowEditing = true;
|
|
}
|
|
private void InsertFolder(BeWoFolderDC folder)
|
|
{
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s => s.InsertNewFolder(folder),
|
|
r =>
|
|
{
|
|
folder.BeWoFolderOid = r;
|
|
folder.BeWoFolderVersion = 1;
|
|
});
|
|
}
|
|
private void DeleteFolderWithAllSubfolders(BeWoFolderDC folder)
|
|
{
|
|
var row = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
if (row == null)
|
|
return;
|
|
if (MessageBox.Show("ACHTUNG: Das Löschen von Ordnern kann nicht rückgängig gemacht werden!\nWollen Sie den Ordner '" + folder.Name + "' mit allen" +
|
|
" sich in diesem befindlichen Dateien und Ordnern wirklich löschen?", "Löschen bestätigen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
|
|
return;
|
|
|
|
ExecuteDelete(folder);
|
|
|
|
if (row.DataContract.Node.ParentNode != null)
|
|
row.DataContract.Node.ParentNode.Nodes.Remove(row.DataContract.Node);
|
|
}
|
|
|
|
private void ExecuteDelete(BeWoFolderDC folder)
|
|
{
|
|
var row = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
|
|
if (folder.Files.Count > 0)
|
|
{
|
|
for (int i = folder.Files.Count - 1; i >= 0; i--)
|
|
{
|
|
var file = folder.Files[i];
|
|
ServiceFacade.DoOperationsServiceAsync(s => s.DeleteFileAttachment(file.FileAttachmentOid.Value, file.FileAttachmentVersion.Value));
|
|
row.DataContract.FilesInFolder.Remove(file);
|
|
}
|
|
}
|
|
|
|
if (folder.SubFolders.Count != 0)
|
|
{
|
|
for (int i = folder.SubFolders.Count - 1; i >= 0; i--)
|
|
{
|
|
var tempFolder = folder.SubFolders[i];
|
|
folder.SubFolders.Remove(tempFolder);
|
|
ExecuteDelete(tempFolder);
|
|
}
|
|
}
|
|
ServiceFacade.DoOperationsServiceSync(s => s.DeleteFolder((long)folder.BeWoFolderOid, (long)folder.BeWoFolderVersion));
|
|
}
|
|
|
|
private void DocumentsTreeView_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)
|
|
{
|
|
if (DocumentsTreeView.AllowEditing == true)
|
|
DocumentsTreeView.AllowEditing = false;
|
|
}
|
|
private void DocumentsTreeView_LostFocus(object sender, RoutedEventArgs e)
|
|
{
|
|
var row = DocumentsTreeView.FocusedRow as DocumentTreeItemVM;
|
|
|
|
if (row != null)
|
|
{
|
|
if (row.IsDirty && !row.Name.Equals(row.DataContract.Name))
|
|
{
|
|
row.DataContract.BeWoFolderDC.Name = row.Name;
|
|
row.DataContract.Name = row.Name;
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s => s.UpdateFolder(row.DataContract.BeWoFolderDC),
|
|
r => row.DataContract.BeWoFolderDC.BeWoFolderVersion = r.BeWoFolderVersion);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void popupedit_file_PopUpClick(object sender, RoutedEventArgs pe)
|
|
{
|
|
var dlg = new OpenFileDialog();
|
|
|
|
if (dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
try
|
|
{
|
|
_UploadFileName = dlg.FileName;
|
|
|
|
_NormalFileName = dlg.SafeFileName;
|
|
_FileNotice = textbox_fileNotice.Text;
|
|
button_uploadDocument.IsEnabled = true;
|
|
|
|
button_uploadDocument_Click(sender, pe);
|
|
|
|
textbox_fileNotice.Text = "";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void button_uploadDocument_Click(object sender, RoutedEventArgs pe)
|
|
{
|
|
if (!String.IsNullOrEmpty(_NormalFileName))
|
|
{
|
|
var selectedTreeViewRow = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
var selectedFolder = selectedTreeViewRow.DataContract.BeWoFolderDC;
|
|
long? bewoFolderOid = selectedFolder.BeWoFolderOid;
|
|
TableID tableID = selectedFolder.ObjectTid;
|
|
long? objectOid = selectedFolder.ObjectOid;
|
|
|
|
try
|
|
{
|
|
var upload = new ProgressStream(File.OpenRead(_UploadFileName));
|
|
upload.ProgressChanged += (s, e) => Dispatcher.BeginInvoke(
|
|
DispatcherPriority.Normal,
|
|
(Action)(() =>
|
|
{
|
|
progressbar_upload.Visibility = Visibility.Visible;
|
|
text_progress.Visibility = Visibility.Visible;
|
|
progressbar_upload.Value = e.Data;
|
|
text_progress.Content = string.Format("Bitte warten... {0:00}%", e.Data * 100);
|
|
}));
|
|
|
|
var lUlPackage = new UploadPackage(bewoFolderOid, 0, _NormalFileName, _FileNotice, objectOid ?? 0, (int)tableID, upload);
|
|
|
|
ServiceFacade.DoStreamingServiceAsync(
|
|
s => s.UploadDocument(lUlPackage),
|
|
r => this.Dispatch(
|
|
delegate
|
|
{
|
|
var newFileVM = new FileAttachmentVM(r.Attachment);
|
|
selectedFolder.Files.Add(newFileVM.DataContract);
|
|
selectedTreeViewRow.DataContract.FilesInFolder.Add(newFileVM.DataContract);
|
|
|
|
//Warum klappt das nicht??
|
|
var vmlist = datagrid_documents.ItemsSource as List<FileAttachmentVM>;
|
|
vmlist.Add(newFileVM);
|
|
datagrid_documents.ItemsSource = vmlist;
|
|
|
|
progressbar_upload.Value = 0;
|
|
text_progress.Content = string.Empty;
|
|
|
|
_UploadFileName = null;
|
|
button_uploadDocument.IsEnabled = false;
|
|
_NormalFileName = string.Empty;
|
|
_FileNotice = string.Empty;
|
|
|
|
progressbar_upload.Visibility = Visibility.Collapsed;
|
|
text_progress.Visibility = Visibility.Collapsed;
|
|
button_uploadDocument.IsEnabled = true;
|
|
|
|
|
|
upload.Dispose();
|
|
}),
|
|
() => this.Dispatch(
|
|
delegate
|
|
{
|
|
progressbar_upload.Value = 0;
|
|
text_progress.Content = string.Empty;
|
|
upload.Dispose();
|
|
|
|
}));
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
}
|
|
}
|
|
private void DocumentsTreeView_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
var source = e.Source as TreeListView;
|
|
if (source.SelectedRows.Count == 1)
|
|
{
|
|
var selected = source.SelectedRows[0] as DocumentTreeItemVM;
|
|
|
|
if (selected == null)
|
|
return;
|
|
|
|
var vmList = new List<FileAttachmentVM>();
|
|
|
|
if (selected.DataContract.FilesInFolder != null)
|
|
{
|
|
List<FileAttachmentDC> list = selected.DataContract.FilesInFolder;
|
|
foreach (var file in list)
|
|
{
|
|
vmList.Add(new FileAttachmentVM(file));
|
|
}
|
|
}
|
|
|
|
datagrid_documents.ItemsSource = vmList;
|
|
}
|
|
}
|
|
private void DeleteButton_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var row = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
var selectedFile = this.datagrid_documents.GetFocusedRow() as FileAttachmentVM;
|
|
if (selectedFile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (MessageBox.Show("ACHTUNG: Das Löschen von Dateien kann nicht rückgängig gemacht werden!\nWollen Sie das Dokument '" + selectedFile.FileName + "' wirklich löschen?", "Löschen bestätigen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(selectedFile.DataContract.FileAttachmentOid != null)
|
|
{
|
|
ServiceFacade.DoOperationsServiceAsync(s => s.DeleteFileAttachment(selectedFile.DataContract.FileAttachmentOid.Value, selectedFile.DataContract.FileAttachmentVersion.Value));
|
|
row.DataContract.FilesInFolder.Remove(selectedFile.DataContract);
|
|
row.DataContract.BeWoFolderDC.Files.Remove(selectedFile.DataContract);
|
|
this.datagrid_documents.ItemsSource = row.DataContract.FilesInFolder;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private void Hyperlink_OnRequestNavigate(object sender, RequestNavigateEventArgs e)
|
|
{
|
|
var navitageUri = ((Hyperlink)sender).NavigateUri.ToString();
|
|
var splittedUri = navitageUri.Split('=');
|
|
var fileOid = 0L;
|
|
long.TryParse(splittedUri[1], out fileOid);
|
|
|
|
try
|
|
{
|
|
var lFA = new FileAttachmentDC();
|
|
|
|
ServiceFacade.DoDownloadServiceAsync(d => lFA = d.GetFileAttachment(fileOid),
|
|
cb => this.Dispatch(delegate
|
|
{
|
|
try
|
|
{
|
|
if (lFA.URL == null)
|
|
return;
|
|
|
|
var odialog = new OpenOrSaveDialog(lFA.FileName);
|
|
odialog.ShowDialog();
|
|
|
|
if (odialog.Selection == null)
|
|
return;
|
|
|
|
if (!odialog.Selection.Value)
|
|
{
|
|
var tmp = Path.GetTempPath() + Path.GetFileName(lFA.URL);
|
|
|
|
|
|
BeWoApp.CurrentBeWo.DocumentWatcher.FileCreated -= DocumentWatcher_FileCreated;
|
|
BeWoApp.CurrentBeWo.DocumentWatcher.FileDeleted -= DocumentWatcher_FileDeleted;
|
|
BeWoApp.CurrentBeWo.DocumentWatcher.StoppeDateiUeberwachung(tmp);
|
|
|
|
if (File.Exists(tmp))
|
|
File.Delete(tmp);
|
|
|
|
using (var uFileStream = File.Create(tmp))
|
|
{
|
|
uFileStream.Write(lFA.BinaryData, 0, lFA.BinaryData.Length);
|
|
}
|
|
|
|
System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(tmp));
|
|
|
|
|
|
|
|
BeWoApp.CurrentBeWo.DocumentWatcher.StarteDateiUeberwachung(new DocumentWatcherInfo(tmp, cb.Description, cb.BeWoFolderOid, cb.FileAttachmentOid, cb.FileAttachmentVersion, _ObjectOid, _ObjectTid));
|
|
BeWoApp.CurrentBeWo.DocumentWatcher.FileCreated += DocumentWatcher_FileCreated;
|
|
BeWoApp.CurrentBeWo.DocumentWatcher.FileDeleted += DocumentWatcher_FileDeleted;
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
if (odialog.Selection.Value)
|
|
{
|
|
var sf = new SaveFileDialog { FileName = Path.GetFileName(lFA.URL) };
|
|
if (sf.ShowDialog() != DialogResult.OK)
|
|
return;
|
|
|
|
using (var myStream = (FileStream)sf.OpenFile())
|
|
{
|
|
myStream.Write(lFA.BinaryData, 0, lFA.BinaryData.Length);
|
|
myStream.Close();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Beim Öffnen des Dokuments ist leider ein Fehler aufgetreten:\n" + ex.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
|
|
}));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
}
|
|
|
|
private void DocumentWatcher_FileDeleted(long? folderOid, long? objectOid, TableID objectTid, long fileAttachmentOid)
|
|
{
|
|
if (objectOid == _ObjectOid && objectTid == _ObjectTid)
|
|
{
|
|
var selectedTreeViewColumn = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
foreach (var file in selectedTreeViewColumn.DataContract.FilesInFolder)
|
|
{
|
|
|
|
}
|
|
// BeWoFolderVM parentFolder = GetFolderWithOid(folderOid);
|
|
//if (parentFolder != null)
|
|
//{
|
|
// FileAttachmentVM fileToDelete = null;
|
|
// foreach (var file in parentFolder.Files)
|
|
// {
|
|
// if (file.DataContract.FileAttachmentOid == fileAttachmentOid)
|
|
// {
|
|
// fileToDelete = file;
|
|
// }
|
|
// }
|
|
|
|
// if (fileToDelete != null)
|
|
// {
|
|
// parentFolder.Files.Remove(fileToDelete);
|
|
// BeWoWpfUtils.RefreshDXGrid(this.datagrid_documents);
|
|
// }
|
|
//}
|
|
}
|
|
}
|
|
|
|
private void DocumentWatcher_FileCreated(long? folderOid, long? objectOid, TableID objectTid, FileAttachmentDC fileAttachment)
|
|
{
|
|
//if (objectOid == _ObjectOid && objectTid == _ObjectTid)
|
|
//{
|
|
// BeWoFolderVM folder = GetFolderWithOid(folderOid);
|
|
// if (folder != null)
|
|
// {
|
|
// var newFileVM = new FileAttachmentVM(fileAttachment);
|
|
// BeWoApp.CurrentBeWo.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)delegate
|
|
// {
|
|
// folder.Files.Add(newFileVM);
|
|
// newFileVM.Folder = folder;
|
|
// });
|
|
// }
|
|
//}
|
|
}
|
|
|
|
private void ItemContainerGenerator_StatusChanged(object sender, EventArgs e)
|
|
{
|
|
var ig = (ItemContainerGenerator)sender;
|
|
if (ig.Status != GeneratorStatus.ContainersGenerated)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var n = ig.ContainerFromIndex(_SelectedTreeNode.Items.Count - 1) as TreeViewItem;
|
|
n.IsSelected = true;
|
|
|
|
new DispatcherTimer(
|
|
TimeSpan.FromMilliseconds(200),
|
|
DispatcherPriority.Background,
|
|
(s1, e1) =>
|
|
{
|
|
_SelectedTreeNode = n;
|
|
EditSelected();
|
|
((DispatcherTimer)s1).Stop();
|
|
},
|
|
Dispatcher).Start();
|
|
|
|
_SelectedTreeNode.ItemContainerGenerator.StatusChanged -= ItemContainerGenerator_StatusChanged;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
public void InitTemplateMenuItems()
|
|
{
|
|
template_treeview_control.BeginDataUpdate();
|
|
|
|
Dictionary<string, string> firstLevel = GetFirstLevelDictionaryForTemplates();
|
|
|
|
var liste = ServiceFacade.DoOperationsServiceSync(s => s.GetVorlagentabelleDCs());
|
|
|
|
string[] iconNames = new string[] { "IDBadgeDisabled", "UserHomeMaleDisabled", "UserBusinessMaleDisabled" };
|
|
int counter = 1;
|
|
foreach (var table in liste)
|
|
{
|
|
TreeListNode node = new TreeListNode();
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = counter,
|
|
ParentOid = null,
|
|
Name = table.Tabellenname,
|
|
Table = TableID.Vorlagentabelle,
|
|
ObjectOid = table.VorlagentabelleOid
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
node.Content = vm;
|
|
TemplateTreeView.Nodes.Add(node);
|
|
node.IsExpandButtonVisible = DefaultBoolean.True;
|
|
node.Tag = false;
|
|
node.Image = LoadImage(iconNames[counter - 1]);
|
|
counter++;
|
|
}
|
|
template_treeview_control.EndDataUpdate();
|
|
}
|
|
|
|
private Dictionary<string, string> GetFirstLevelDictionaryForTemplates()
|
|
{
|
|
Dictionary<string, string> firstLevel = new Dictionary<string, string>();
|
|
|
|
firstLevel.Add("supportConcepts", "Hilfepläne");
|
|
firstLevel.Add("customers", "Klienten");
|
|
firstLevel.Add("employee", "Mitarbeiter");
|
|
|
|
return firstLevel;
|
|
}
|
|
|
|
private void templateTreeListView_NodeExpanding(object sender, TreeListNodeAllowEventArgs e)
|
|
{
|
|
TreeListNode node = e.Node;
|
|
var vm = node.Content as DocumentTreeItemVM;
|
|
|
|
if (vm.Name.Equals("Hilfepläne") || vm.Name.Equals("Klienten") || vm.Name.Equals("Mitarbeiter"))
|
|
{
|
|
List<BeWoFolderDC> folderDCs = new List<BeWoFolderDC>();
|
|
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Vorlagentabelle, (long)vm.DocTreeItemOid);
|
|
|
|
GenerateFolderStructureForSelectedNode(node, folderDCs);
|
|
}
|
|
|
|
|
|
|
|
//Templates_SubNode_Expended(node);
|
|
|
|
//if (vm.ParentOid == null)
|
|
//{
|
|
// switch (vm.Name)
|
|
// {
|
|
// case "Hilfepläne": Templates_SupportConcepts_Expended(node); break;
|
|
// case "Klienten": Templates_Customers_Expended(node); break;
|
|
// case "Mitarbeiter": Templates_Employee_Expended(node); break;
|
|
// }
|
|
//}
|
|
//else
|
|
//{
|
|
// Templates_SubNode_Expended(node);
|
|
//}
|
|
}
|
|
private void Templates_SubNode_Expended(TreeListNode node)
|
|
{
|
|
//var parentNode = node.ParentNode;
|
|
//DocumentTreeItemVM parentContent;
|
|
//if(parentNode.Content != null)
|
|
// parentContent = parentNode.Content as DocumentTreeItemVM;
|
|
var content = node.Content as DocumentTreeItemVM;
|
|
|
|
|
|
}
|
|
|
|
private void Templates_SupportConcepts_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void Templates_Customers_Expended(TreeListNode node)
|
|
{
|
|
|
|
}
|
|
|
|
private void Templates_Employee_Expended(TreeListNode node)
|
|
{
|
|
|
|
}
|
|
private void TemplateContextMenu_Opened(object sender, RoutedEventArgs e)
|
|
{
|
|
if (e.OriginalSource is ContextMenu)
|
|
{
|
|
ContextMenu menu = e.OriginalSource as ContextMenu;
|
|
|
|
DocumentTreeItemVM treeviewitem = this.template_treeview_control.SelectedItem as DocumentTreeItemVM;
|
|
|
|
foreach (var item in menu.Items)
|
|
{
|
|
if (item is MenuItem)
|
|
{
|
|
MenuItem menuitem = item as MenuItem;
|
|
|
|
if (treeviewitem.DataContract.BeWoFolderDC != null)
|
|
{
|
|
if (treeviewitem.Name.Equals("Alle Ordner"))
|
|
{
|
|
if (menuitem.Header.Equals("Neu"))
|
|
menuitem.IsEnabled = true;
|
|
else
|
|
menuitem.IsEnabled = false;
|
|
}
|
|
else
|
|
{
|
|
menuitem.IsEnabled = true;
|
|
}
|
|
}
|
|
else
|
|
menuitem.IsEnabled = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private void TemplateContextMenu_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if (e.OriginalSource is MenuItem)
|
|
{
|
|
var row = TemplateTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
var twi = e.OriginalSource as MenuItem;
|
|
|
|
if (twi.Header.Equals("Neu"))
|
|
{
|
|
TreeListNode node = new TreeListNode();
|
|
node.IsExpandButtonVisible = DefaultBoolean.True;
|
|
node.Tag = false;
|
|
node.Image = LoadFolderImage();
|
|
|
|
BeWoFolderDC folderDC = new BeWoFolderDC()
|
|
{
|
|
Name = "Neuer Ordner",
|
|
ParentBeWoFolderOid = row.DataContract.BeWoFolderDC.BeWoFolderOid,
|
|
ObjectOid = row.DataContract.ObjectOid,
|
|
ObjectTid = row.DataContract.Table,
|
|
Files = new List<FileAttachmentDC>(),
|
|
SubFolders = new List<BeWoFolderDC>()
|
|
};
|
|
InsertFolder(folderDC);
|
|
|
|
row.DataContract.BeWoFolderDC.SubFolders.Add(folderDC);
|
|
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
Name = "Neuer Ordner",
|
|
DocTreeItemOid = folderDC.BeWoFolderOid,
|
|
ParentOid = row.DocTreeItemOid,
|
|
BeWoFolderDC = folderDC,
|
|
Table = row.DataContract.Table,
|
|
ObjectOid = row.DataContract.ObjectOid,
|
|
FilesInFolder = new List<FileAttachmentDC>(),
|
|
Node = node
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
dc.Node.Content = vm;
|
|
row.DataContract.Node.Nodes.Add(dc.Node);
|
|
}
|
|
else if (twi.Header.Equals("Umbenennen"))
|
|
{
|
|
this.EditSelectedTemplateFolder();
|
|
}
|
|
else if (twi.Header.Equals("Löschen"))
|
|
{
|
|
this.DeleteTemplateFolderWithAllSubfolders(row.DataContract.BeWoFolderDC);
|
|
}
|
|
else if (twi.Header.Equals("Neue Vorlage"))
|
|
{
|
|
var vm = new DokumentvorlageVM(new DokumentvorlageDC());
|
|
|
|
VorlagentabelleDC tabelle = ServiceFacade.DoOperationsServiceSync(s => s.GetVorlagentabelleById((long)row.DataContract.BeWoFolderDC.ObjectOid));
|
|
vm.Tabellenzugehoerigkeit = (long)tabelle.VorlagentabelleObjectTid;
|
|
vm.Parent = row.DataContract.BeWoFolderDC.BeWoFolderOid;
|
|
|
|
var savedTemplate = EditTemplate(vm);
|
|
if(savedTemplate != null)
|
|
SaveInDatabase(savedTemplate);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private DokumentvorlageVM EditTemplate(DokumentvorlageVM vm)
|
|
{
|
|
var row = TemplateTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
var folder = ServiceFacade.DoOperationsServiceSync(s => s.GetFolderById((long)row.DocTreeItemOid));
|
|
long? tabelle = folder.ObjectOid;
|
|
|
|
var control = new VorlageEditView();
|
|
|
|
control.InitView(vm, tabelle);
|
|
var beWoWindow = new BeWoWindow
|
|
{
|
|
rootGroupBox = { Header = "Vorlage bearbeiten" },
|
|
Height = this.Height,
|
|
Width = 1000,
|
|
MinWidth = 550,
|
|
WindowStartupLocation = WindowStartupLocation.CenterOwner,
|
|
GroupBoxContent = control,
|
|
Owner = BeWoApp.CurrentBeWo.MainWindow
|
|
};
|
|
bool saved = false;
|
|
|
|
control.ButtonSavedClicked += () =>
|
|
{
|
|
saved = true;
|
|
beWoWindow.Close();
|
|
};
|
|
|
|
control.ButtonCancelClicked += () =>
|
|
{
|
|
beWoWindow.Close();
|
|
};
|
|
|
|
beWoWindow.ShowDialog();
|
|
|
|
if (!saved)
|
|
{
|
|
return null;
|
|
}
|
|
return control.ViewModel;
|
|
}
|
|
|
|
private void SaveInDatabase(DokumentvorlageVM savedTemplate)
|
|
{
|
|
var dc = savedTemplate.CommitToDataContract();
|
|
var textasbytes = Encoding.ASCII.GetBytes(dc.RTFText);
|
|
dc.Data = textasbytes;
|
|
ServiceFacade.DoOperationsServiceSync(s => s.InsertTemplate(dc));
|
|
|
|
}
|
|
|
|
private void EditSelectedTemplateFolder()
|
|
{
|
|
TemplateTreeView.AllowEditing = true;
|
|
}
|
|
|
|
private void TemplateTreeView_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)
|
|
{
|
|
if (TemplateTreeView.AllowEditing == true)
|
|
TemplateTreeView.AllowEditing = false;
|
|
}
|
|
private void TemplateTreeView_LostFocus(object sender, RoutedEventArgs e)
|
|
{
|
|
var row = TemplateTreeView.FocusedRow as DocumentTreeItemVM;
|
|
|
|
if (row != null)
|
|
{
|
|
if (row.IsDirty && !row.Name.Equals(row.DataContract.Name))
|
|
{
|
|
row.DataContract.BeWoFolderDC.Name = row.Name;
|
|
row.DataContract.Name = row.Name;
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s => s.UpdateFolder(row.DataContract.BeWoFolderDC),
|
|
r => row.DataContract.BeWoFolderDC.BeWoFolderVersion = r.BeWoFolderVersion);
|
|
}
|
|
}
|
|
}
|
|
private void DeleteTemplateFolderWithAllSubfolders(BeWoFolderDC folder)
|
|
{
|
|
var row = TemplateTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
if (row == null)
|
|
return;
|
|
if (MessageBox.Show("ACHTUNG: Das Löschen von Ordnern kann nicht rückgängig gemacht werden!\nWollen Sie den Ordner '" + folder.Name + "' mit allen" +
|
|
" sich in diesem befindlichen Dateien und Ordnern wirklich löschen?", "Löschen bestätigen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
|
|
return;
|
|
|
|
TemplateExecuteDelete(folder);
|
|
|
|
if (row.DataContract.Node.ParentNode != null)
|
|
row.DataContract.Node.ParentNode.Nodes.Remove(row.DataContract.Node);
|
|
}
|
|
|
|
private void TemplateExecuteDelete(BeWoFolderDC folder)
|
|
{
|
|
var row = TemplateTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
|
|
|
|
var templatesInFolder = datagrid_templates.ItemsSource as List<DokumentvorlageVM>;
|
|
List<DokumentvorlageDC> dcs = new List<DokumentvorlageDC>();
|
|
if (templatesInFolder == null)
|
|
return;
|
|
else if(templatesInFolder.Count != 0)
|
|
{
|
|
foreach (var t in templatesInFolder)
|
|
{
|
|
dcs.Add(t.DataContract);
|
|
}
|
|
ServiceFacade.DoOperationsServiceSync(s => s.DeleteTemplates(dcs));
|
|
}
|
|
|
|
if (folder.SubFolders.Count != 0)
|
|
{
|
|
for (int i = folder.SubFolders.Count - 1; i >= 0; i--)
|
|
{
|
|
var tempFolder = folder.SubFolders[i];
|
|
folder.SubFolders.Remove(tempFolder);
|
|
TemplateExecuteDelete(tempFolder);
|
|
}
|
|
}
|
|
ServiceFacade.DoOperationsServiceSync(s => s.DeleteFolder((long)folder.BeWoFolderOid, (long)folder.BeWoFolderVersion));
|
|
}
|
|
|
|
private void TemplateTreeView_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
var source = e.Source as TreeListView;
|
|
if (source.SelectedRows.Count == 1)
|
|
{
|
|
var selected = source.SelectedRows[0] as DocumentTreeItemVM;
|
|
|
|
if (selected == null || selected.Name.Equals("Alle Ordner"))
|
|
return;
|
|
|
|
var vmList = new List<DokumentvorlageVM>();
|
|
|
|
//BeWoFolderDC folderDC = ServiceFacade.DoOperationsServiceSync(s => s.GetFolderById((long)selected.DocTreeItemOid));
|
|
//var folderDC_Oid = folderDC.BeWoFolderOid;
|
|
if (selected.DataContract.BeWoFolderDC == null)
|
|
return;
|
|
var maybeRightOid = selected.DataContract.BeWoFolderDC.BeWoFolderOid;
|
|
//if(folderDC != null)
|
|
//{
|
|
var folderOid = maybeRightOid;
|
|
|
|
var vorlagenInOrdner = ServiceFacade.DoOperationsServiceSync(s => s.GetDokumentvorlagenInFolder((long)folderOid));
|
|
foreach(DokumentvorlageDC dc in vorlagenInOrdner)
|
|
{
|
|
vmList.Add(new DokumentvorlageVM(dc));
|
|
}
|
|
datagrid_templates.ItemsSource = vmList;
|
|
|
|
//}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
private void EditTemplate_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var templateVM = datagrid_templates.SelectedItem as DokumentvorlageVM;
|
|
EditTemplate(templateVM);
|
|
if(templateVM.IsDirty)
|
|
SaveInDatabase(templateVM);
|
|
}
|
|
}
|
|
}
|