2082 lines
87 KiB
C#
2082 lines
87 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;
|
|
using BS.Shared.Translation;
|
|
using System.Windows.Data;
|
|
using System.Globalization;
|
|
|
|
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;
|
|
|
|
if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.DocumentsUploadAll))
|
|
{
|
|
button_uploadDocument.Visibility = Visibility.Collapsed;
|
|
}
|
|
|
|
if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.DocumentsDownloadAll))
|
|
{
|
|
ColumnDownload.Visible = false;
|
|
ColumnDownload.ShowInColumnChooser = false;
|
|
}
|
|
|
|
}
|
|
|
|
public void InitDocumentMenuItems()
|
|
{
|
|
documents_treeview_control.BeginDataUpdate();
|
|
|
|
var firstLevel = GetFirstLevelDictionaryForDocuments();
|
|
|
|
int counter = 1;
|
|
foreach (var docNodeConfig in firstLevel)
|
|
{
|
|
bool hatViewRight = false;
|
|
|
|
if (BeWoApp.LoggedOnUser.HasRight(docNodeConfig.DocumentRightNeeded))
|
|
{
|
|
foreach(var r in docNodeConfig.ListOfViewRightsNeeded)
|
|
{
|
|
if (BeWoApp.LoggedOnUser.HasRight(r))
|
|
{
|
|
hatViewRight = true;
|
|
}
|
|
}
|
|
|
|
}
|
|
if (hatViewRight)
|
|
{
|
|
TreeListNode node = new TreeListNode();
|
|
DocumentTreeItemDC dc = new DocumentTreeItemDC()
|
|
{
|
|
DocTreeItemOid = counter,
|
|
ParentOid = null,
|
|
Name = docNodeConfig.Title,
|
|
Table = docNodeConfig.TableID
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
node.Content = vm;
|
|
node.Tag = docNodeConfig;
|
|
DocumentsTreeView.Nodes.Add(node);
|
|
node.IsExpandButtonVisible = DefaultBoolean.True;
|
|
node.Image = LoadImage(docNodeConfig.IconName);
|
|
}
|
|
counter++;
|
|
}
|
|
documents_treeview_control.EndDataUpdate();
|
|
}
|
|
|
|
private IList<DocumentRootNodeConfig> GetFirstLevelDictionaryForDocuments()
|
|
{
|
|
|
|
var list = new List<DocumentRootNodeConfig>();
|
|
list.Add(new DocumentRootNodeConfig { TableID = TableID.FinanzDokumente, Title = Translator.TranslateKey("DocumentViewFinanzen", "Finanzen"), IconName = "CoinsDisabled", DocumentRightNeeded = UserRightType.DokumenteFinanzen, ListOfViewRightsNeeded = new List<UserRightType> { UserRightType.AccountingTransactionView_View } });
|
|
list.Add(new DocumentRootNodeConfig { TableID = TableID.SupportConcept, Title = Translator.TranslateKey("DocumentViewSupportConcept", "Hilfepläne"), IconName = "IDBadgeDisabled", DocumentRightNeeded = UserRightType.DokumenteHilfeplaene, ListOfViewRightsNeeded = new List<UserRightType> { UserRightType.SupportConceptView_View, UserRightType.SupportConcept_ViewMyTeams, UserRightType.SupportConcept_ViewAllSupportConcepts } });
|
|
list.Add(new DocumentRootNodeConfig { TableID = TableID.Customer, Title = Translator.TranslateKey("DocumentViewCustomer", "Klienten"), IconName = "UserHomeMaleDisabled", DocumentRightNeeded = UserRightType.DokumenteKlienten, ListOfViewRightsNeeded = new List<UserRightType> { UserRightType.CustomerView_View, UserRightType.Customer_ViewMyCustomers, UserRightType.Customer_ViewMyTeams } });
|
|
list.Add(new DocumentRootNodeConfig { TableID = TableID.Organisation, Title = Translator.TranslateKey("DocumentViewOrganisation", "Organisationen"), IconName = "OfficeBulidingBlackDisabled", DocumentRightNeeded = UserRightType.DokumenteOrganisationen, ListOfViewRightsNeeded = new List<UserRightType> { UserRightType.OrganisationView_View } });
|
|
list.Add(new DocumentRootNodeConfig { TableID = TableID.Person, Title = Translator.TranslateKey("DocumentViewPerson", "Personen"), IconName = "AnonymousUserDisabled", DocumentRightNeeded = UserRightType.DokumentePersonen, ListOfViewRightsNeeded = new List<UserRightType> { UserRightType.PersonView_View, UserRightType.Person_FamilyView } });
|
|
list.Add(new DocumentRootNodeConfig { TableID = TableID.Employee, Title = Translator.TranslateKey("DocumentViewEmployee", "Mitarbeiter"), IconName = "UserBusinessMaleDisabled", DocumentRightNeeded = UserRightType.DokumenteMitarbeiter, ListOfViewRightsNeeded = new List<UserRightType> { UserRightType.EmployeeView_View, UserRightType.Employee_AllowViewOwnEmployees, UserRightType.Employee_AllowViewOwnTeam } });
|
|
list.Add(new DocumentRootNodeConfig { TableID = TableID.Team, Title = Translator.TranslateKey("DocumentViewTeam", "Teams"), IconName = "UserGroupBusinessDisabled", DocumentRightNeeded = UserRightType.DokumenteTeams, ListOfViewRightsNeeded = new List<UserRightType> { UserRightType.TeamView_ViewAll, UserRightType.TeamView_ViewMyTeams, UserRightType.SupportConcept_ViewAllSupportConcepts } });
|
|
list.Add(new DocumentRootNodeConfig { TableID = TableID.ApplicationUser, Title = Translator.TranslateKey("DocumentViewUser", "Benutzer"), IconName = "UserBusinessMaleDisabled", DocumentRightNeeded = UserRightType.UserView_View, ListOfViewRightsNeeded = new List<UserRightType> { UserRightType.UserView_View } });
|
|
//firstLevel.Add("usergroups", "Benutzergruppen");
|
|
|
|
return list;
|
|
}
|
|
|
|
private void DocumentsTreeView_NodeExpanding(object sender, TreeListNodeAllowEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
Mouse.OverrideCursor = System.Windows.Input.Cursors.Wait;
|
|
TreeListNode node = e.Node;
|
|
var dcNodeConfig = node.Tag as DocumentRootNodeConfig;
|
|
|
|
//var vm = node.Content as DocumentTreeItemVM;
|
|
|
|
if (dcNodeConfig != null)
|
|
{
|
|
switch (dcNodeConfig.TableID)
|
|
{
|
|
case TableID.FinanzDokumente: SubNode_Expended(node); break;
|
|
case TableID.SupportConcept: SupportConcepts_Expended(node); break;
|
|
case TableID.Customer: Customers_Expended(node); break;
|
|
case TableID.Organisation: Organisations_Expended(node); break;
|
|
case TableID.Person: People_Expended(node); break;
|
|
case TableID.Employee: Employee_Expended(node); break;
|
|
case TableID.Team: Teams_Expended(node); break;
|
|
case TableID.ApplicationUser: Users_Expended(node); break;
|
|
case TableID.UserGroup: UserGroups_Expended(node); break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SubNode_Expended(node);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
|
|
Mouse.OverrideCursor = null;
|
|
}
|
|
|
|
}
|
|
|
|
private void SubNode_Expended(TreeListNode node)
|
|
{
|
|
List<BeWoFolderDC> folderDCs = new List<BeWoFolderDC>();
|
|
var config = node.Tag as DocumentRootNodeConfig;
|
|
|
|
if (config != null && config.TableID == TableID.FinanzDokumente)
|
|
{
|
|
folderDCs = VMFactory.CreateFolderList(TableID.FinanzDokumente, 0);
|
|
}
|
|
else
|
|
{
|
|
var treeItemVm = node.Content as DocumentTreeItemVM;
|
|
|
|
var parentNode = node.ParentNode;
|
|
var parentContent = parentNode.Content as DocumentTreeItemVM;
|
|
var parentConfig = parentNode.Tag as DocumentRootNodeConfig;
|
|
|
|
|
|
if (parentConfig != null && parentConfig.TableID == TableID.SupportConcept)
|
|
{
|
|
//SupportConcept
|
|
folderDCs = VMFactory.CreateFolderList(TableID.SupportConcept, (long)treeItemVm.DocTreeItemOid);
|
|
}
|
|
else if (parentConfig != null && parentConfig.TableID == TableID.Customer)
|
|
{
|
|
//Customer
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Customer, (long)treeItemVm.DocTreeItemOid);
|
|
}
|
|
else if (parentConfig != null && parentConfig.TableID == TableID.Organisation)
|
|
{
|
|
//Organisation
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Organisation, (long)treeItemVm.DocTreeItemOid);
|
|
}
|
|
else if (parentConfig != null && parentConfig.TableID == TableID.Person)
|
|
{
|
|
//Person
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Person, (long)treeItemVm.DocTreeItemOid);
|
|
}
|
|
else if (parentConfig != null && parentConfig.TableID == TableID.Employee)
|
|
{
|
|
//Employee
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Employee, (long)treeItemVm.DocTreeItemOid);
|
|
}
|
|
else if (parentConfig != null && parentConfig.TableID == TableID.Team)
|
|
{
|
|
//Team
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Team, (long)treeItemVm.DocTreeItemOid);
|
|
}
|
|
else if (parentConfig != null && parentConfig.TableID == TableID.ApplicationUser)
|
|
{
|
|
//User
|
|
folderDCs = VMFactory.CreateFolderList(TableID.ApplicationUser, (long)treeItemVm.DocTreeItemOid);
|
|
}
|
|
else if (parentConfig != null && parentConfig.TableID == TableID.UserGroup)
|
|
{
|
|
//UserGroup
|
|
folderDCs = VMFactory.CreateFolderList(TableID.UserGroup, (long)treeItemVm.DocTreeItemOid);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
GenerateFolderStructureForSelectedNode(node, folderDCs, false);
|
|
}
|
|
|
|
private void GenerateFolderStructureForSelectedNode(TreeListNode node, List<BeWoFolderDC> folderDCs, bool hideAlleOrdner)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
var content = node.Content as DocumentTreeItemVM;
|
|
|
|
foreach (var folder in folderDCs)
|
|
{
|
|
TreeListNode newNode_folder = null;
|
|
if (folder.BeWoFolderOid.HasValue || !hideAlleOrdner)
|
|
{
|
|
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);
|
|
newNode_folder = new TreeListNode()
|
|
{
|
|
Content = folder_vm,
|
|
IsExpandButtonVisible = DefaultBoolean.True,
|
|
Tag = false,
|
|
Image = LoadFolderImage()
|
|
};
|
|
folder_dc.Node = newNode_folder;
|
|
node.Nodes.Add(newNode_folder);
|
|
}
|
|
else
|
|
{
|
|
newNode_folder = node;
|
|
if (content.DataContract.BeWoFolderDC == null)
|
|
{
|
|
content.DataContract.BeWoFolderDC = folder;
|
|
}
|
|
|
|
}
|
|
|
|
if (folder.SubFolders.Count != 0)
|
|
{
|
|
GenerateFolderStructureForSelectedNode(newNode_folder, folder.SubFolders, hideAlleOrdner);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//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 Finanzen_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Hilfepläne in eine Liste holen
|
|
var liste = VMFactory.CreateSupportConceptList();
|
|
|
|
|
|
//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 SupportConcepts_Expended(TreeListNode node)
|
|
{
|
|
if (node.Nodes.Count == 0)
|
|
{
|
|
//Alle Hilfepläne in eine Liste holen
|
|
var liste = ServiceFacade.DoCustomerServiceSync(s => s.GetAllAuthorizedCompactSupportConcepts());
|
|
|
|
|
|
//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 = String.Format("{0} | {1}", item.CustomerName, item.FirstCostBearerDetailString),
|
|
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 = ServiceFacade.DoCustomerServiceSync(s => s.GetAllAuthorizedCompactCustomers());
|
|
|
|
|
|
//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().OrderBy(o => o.Name).ToList();
|
|
|
|
|
|
//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();
|
|
var liste = ServiceFacade.DoCustomerServiceSync(s => s.GetAllAuthorizedCompactPersons());
|
|
|
|
//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.DetailDescription,
|
|
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 = ServiceFacade.DoEmployeeServiceSync(s => s.GetAllAuthorizedCompactEmployees());
|
|
|
|
//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().OrderBy(t => t.Name).ToList();
|
|
|
|
|
|
//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 != null && treeviewitem.DataContract.BeWoFolderDC != null && BeWoApp.LoggedOnUser.HasRight(UserRightType.DocumentsEditFolders))
|
|
{
|
|
if (treeviewitem.Name.Equals("Alle Ordner"))
|
|
{
|
|
if (menuitem.Header.Equals("Neuer Ordner"))
|
|
menuitem.IsEnabled = true;
|
|
else
|
|
menuitem.IsEnabled = false;
|
|
}
|
|
else
|
|
{
|
|
menuitem.IsEnabled = true;
|
|
}
|
|
}
|
|
else
|
|
menuitem.IsEnabled = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ContextMenu_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.DocumentsEditFolders))
|
|
{
|
|
return;
|
|
}
|
|
if (e.OriginalSource is MenuItem)
|
|
{
|
|
var row = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
var twi = e.OriginalSource as MenuItem;
|
|
|
|
if (twi.Header.Equals("Neuer Ordner"))
|
|
{
|
|
TreeListNode node = new TreeListNode();
|
|
node.IsExpandButtonVisible = DefaultBoolean.True;
|
|
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;
|
|
|
|
var vm = e.NewRow as DocumentTreeItemVM;
|
|
if (vm != null)
|
|
{
|
|
SetSelectedText(vm);
|
|
SetItemSourceForFileGrid(vm);
|
|
}
|
|
}
|
|
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))
|
|
{
|
|
if(DocumentsTreeView.SelectedRows.Count == 0)
|
|
{
|
|
MessageBox.Show("Wählen Sie links einen Ordner aus, in den die Datei hochgeladen werden soll.", "BeWoPlaner", MessageBoxButton.OK, MessageBoxImage.Information);
|
|
return;
|
|
}
|
|
var selectedTreeViewRow = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
|
|
var selectedFolder = selectedTreeViewRow.DataContract.BeWoFolderDC;
|
|
|
|
long? bewoFolderOid = selectedFolder.BeWoFolderOid;
|
|
TableID tableID = selectedFolder.ObjectTid;
|
|
long? objectOid = selectedFolder.ObjectOid;
|
|
_FileNotice = textbox_beschreibung.Text;
|
|
|
|
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>;
|
|
datagrid_documents.ItemsSource = null;
|
|
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();
|
|
|
|
}));
|
|
popupedit_file.Text = "";
|
|
textbox_beschreibung.Text = "";
|
|
popup_UploadFiles.IsOpen = false;
|
|
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Wählen Sie eine Datei zum hochladen aus.", "BeWoPlaner", MessageBoxButton.OK, MessageBoxImage.Information);
|
|
}
|
|
}
|
|
private void DocumentsTreeView_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
//private void SetSelectedText(TreeListNode node)
|
|
//{
|
|
// var dti = DocumentsTreeView.GetNodeByContent(node);
|
|
//}
|
|
|
|
private void SetSelectedText(DocumentTreeItemVM selected)
|
|
{
|
|
GroupBoxDokumentenListe.Header = "";
|
|
|
|
var node = DocumentsTreeView.GetNodeByContent(selected);
|
|
|
|
AddPathToSelectedText(selected, node);
|
|
//String path = selected.
|
|
|
|
|
|
}
|
|
|
|
private void AddPathToSelectedText(DocumentTreeItemVM vm, TreeListNode node)
|
|
{
|
|
if (vm != null && node != null)
|
|
{
|
|
String path = vm.Name;
|
|
if (!String.IsNullOrEmpty((String)GroupBoxDokumentenListe.Header))
|
|
{
|
|
path = String.Format("{0} > {1}", vm.Name, GroupBoxDokumentenListe.Header);
|
|
}
|
|
GroupBoxDokumentenListe.Header = path;
|
|
if (node.ParentNode != null)
|
|
{
|
|
var parentVm = documents_treeview_control.GetRow(node.ParentNode.RowHandle) as DocumentTreeItemVM;
|
|
|
|
AddPathToSelectedText(parentVm, node.ParentNode);
|
|
|
|
//DocumentsTreeView.GetRowElementByTreeElement(node.ParentNode);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
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);
|
|
|
|
SetItemSourceForFileGrid(row);
|
|
}
|
|
}
|
|
private void EditButton_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var row = DocumentsTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
//var selectedFile = this.datagrid_documents.GetFocusedRow() as FileAttachmentVM;
|
|
var selectedFile = this.datagrid_documents.SelectedItem as FileAttachmentVM;
|
|
if (selectedFile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var control = new DateiBearbeiten();
|
|
control.InitView(selectedFile);
|
|
|
|
var beWoWindow = new BeWoWindow
|
|
{
|
|
rootGroupBox = { Header = "Datei bearbeiten" },
|
|
Height = 100,
|
|
Width = 400,
|
|
MinWidth = 300,
|
|
WindowStartupLocation = WindowStartupLocation.CenterOwner,
|
|
GroupBoxContent = control,
|
|
Owner = BeWoApp.CurrentBeWo.MainWindow
|
|
};
|
|
|
|
List<PrintSelectionVM> printSelectionVMs = new List<PrintSelectionVM>();
|
|
|
|
control.ButtonSaveClicked += () =>
|
|
{
|
|
FileAttachmentVM newVM = control.AktualisierteDatei;
|
|
|
|
row.DataContract.FilesInFolder.Remove(selectedFile.DataContract);
|
|
row.DataContract.BeWoFolderDC.Files.Remove(selectedFile.DataContract);
|
|
|
|
row.DataContract.FilesInFolder.Add(newVM.DataContract);
|
|
row.DataContract.BeWoFolderDC.Files.Add(newVM.DataContract);
|
|
|
|
row.DataContract.FilesInFolder = row.DataContract.FilesInFolder.OrderBy(f => f.InsertedOn).ToList();
|
|
|
|
SetItemSourceForFileGrid(row);
|
|
|
|
beWoWindow.Close();
|
|
return;
|
|
};
|
|
control.ButtonCancelClicked += () =>
|
|
{
|
|
beWoWindow.Close();
|
|
return;
|
|
};
|
|
|
|
beWoWindow.ShowDialog();
|
|
}
|
|
|
|
private void SetItemSourceForFileGrid(DocumentTreeItemVM row)
|
|
{
|
|
this.datagrid_documents.ItemsSource = null;
|
|
|
|
var vmList = new List<FileAttachmentVM>();
|
|
|
|
if (row.DataContract.FilesInFolder != null)
|
|
{
|
|
List<FileAttachmentDC> list = row.DataContract.FilesInFolder;
|
|
foreach (var file in list)
|
|
{
|
|
vmList.Add(new FileAttachmentVM(file));
|
|
}
|
|
}
|
|
|
|
datagrid_documents.ItemsSource = vmList;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Templates / Serienbriefe
|
|
|
|
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,
|
|
BeWoFolderDC = new BeWoFolderDC { Name = "RootFolder", SubFolders = new List<BeWoFolderDC>() }
|
|
};
|
|
DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
|
|
node.Content = vm;
|
|
TemplateTreeView.Nodes.Add(node);
|
|
node.IsExpandButtonVisible = DefaultBoolean.True;
|
|
node.Image = LoadImage(table.ImageName);
|
|
|
|
|
|
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", Translator.Translate("Klienten"));
|
|
firstLevel.Add("employee", Translator.Translate("MitarbeiterPlural"));
|
|
|
|
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>();
|
|
|
|
if (vm.DocTreeItemOid.HasValue)
|
|
{
|
|
folderDCs = VMFactory.CreateFolderList(TableID.Vorlagentabelle, (long)vm.DocTreeItemOid);
|
|
|
|
GenerateFolderStructureForSelectedNode(node, folderDCs, true);
|
|
}
|
|
//}
|
|
|
|
|
|
|
|
//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 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;
|
|
menuitem.IsEnabled = false;
|
|
|
|
if (treeviewitem?.DataContract != null && BeWoApp.LoggedOnUser.HasRight(UserRightType.DocumentsEditFolders))
|
|
{
|
|
if (menuitem.Header.Equals("Neuer Ordner"))
|
|
{
|
|
menuitem.IsEnabled = true;
|
|
}
|
|
else
|
|
{
|
|
if (treeviewitem?.DataContract?.BeWoFolderDC != null && treeviewitem.DataContract.BeWoFolderDC.BeWoFolderOid.HasValue)
|
|
{
|
|
menuitem.IsEnabled = true;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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("Neuer Ordner"))
|
|
{
|
|
TreeListNode node = new TreeListNode();
|
|
node.IsExpandButtonVisible = DefaultBoolean.True;
|
|
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)
|
|
{
|
|
if(savedTemplate.IsDirty)
|
|
{
|
|
SaveInDatabase(savedTemplate);
|
|
|
|
var tableitems = datagrid_templates.ItemsSource as List<DokumentvorlageVM>;
|
|
datagrid_templates.ItemsSource = new List<DokumentvorlageVM>();
|
|
|
|
tableitems.Add(savedTemplate);
|
|
datagrid_templates.ItemsSource = tableitems;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private DokumentvorlageVM EditTemplate(DokumentvorlageVM vm)
|
|
{
|
|
var row = TemplateTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
var folder = ServiceFacade.DoOperationsServiceSync(s => s.GetFolderById((long)row.DataContract.BeWoFolderDC.BeWoFolderOid));
|
|
long? tabelle = folder.ObjectOid;
|
|
|
|
var control = new VorlageEditView();
|
|
|
|
control.InitView(vm, tabelle);
|
|
var beWoWindow = new BeWoWindow
|
|
{
|
|
rootGroupBox = { Header = "Vorlage bearbeiten" },
|
|
Height = this.Height,
|
|
Width = 1200,
|
|
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 DokumentvorlageDC SaveInDatabase(DokumentvorlageVM savedTemplate)
|
|
{
|
|
var dc = savedTemplate.CommitToDataContract();
|
|
var textasbytes = Encoding.ASCII.GetBytes(dc.RTFText);
|
|
dc.Data = textasbytes;
|
|
var updatedDC = ServiceFacade.DoOperationsServiceSync(s => s.InsertTemplate(dc));
|
|
|
|
return updatedDC;
|
|
}
|
|
|
|
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" +
|
|
" enthaltenen Dateien und Unterordnern 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 = ServiceFacade.DoOperationsServiceSync(s => s.GetDokumentvorlagenInFolder((long)folder.BeWoFolderOid));
|
|
|
|
if (templatesInFolder != null)
|
|
{
|
|
if (templatesInFolder.Count != 0)
|
|
{
|
|
ServiceFacade.DoOperationsServiceSync(s => s.DeleteTemplates(templatesInFolder));
|
|
}
|
|
}
|
|
|
|
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.DataContract.BeWoFolderDC.Name == "RootFolder")
|
|
{
|
|
datagrid_templates.ItemsSource = new List<DokumentvorlageVM>();
|
|
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;
|
|
//if(folderDC != null)
|
|
//{
|
|
var folderOid = selected.DataContract.BeWoFolderDC.BeWoFolderOid;
|
|
|
|
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)
|
|
{
|
|
var dc = SaveInDatabase(templateVM);
|
|
templateVM.DataContract = dc;
|
|
}
|
|
|
|
}
|
|
private void PrintTemplate_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var templateVM = datagrid_templates.SelectedItem as DokumentvorlageVM;
|
|
|
|
var liste = ServiceFacade.DoOperationsServiceSync(s => s.GetVorlagentabelleDCs());
|
|
long vorlagentabelle = 0;
|
|
foreach (var item in liste)
|
|
{
|
|
if(item.VorlagentabelleObjectTid == templateVM.Tabellenzugehoerigkeit)
|
|
{
|
|
vorlagentabelle = templateVM.Tabellenzugehoerigkeit;
|
|
break;
|
|
}
|
|
}
|
|
long? tabellenoid = vorlagentabelle;
|
|
|
|
var control = new TemplatePrintSelection();
|
|
control.InitView(tabellenoid);
|
|
|
|
var beWoWindow = new BeWoWindow
|
|
{
|
|
rootGroupBox = { Header = "Auswahl für Vorlage treffen" },
|
|
Height = this.Height,
|
|
Width = 600,
|
|
MinWidth = 400,
|
|
WindowStartupLocation = WindowStartupLocation.CenterOwner,
|
|
GroupBoxContent = control,
|
|
Owner = BeWoApp.CurrentBeWo.MainWindow
|
|
};
|
|
|
|
List<PrintSelectionVM> printSelectionVMs = new List<PrintSelectionVM>();
|
|
|
|
control.ButtonCreateClicked += () =>
|
|
{
|
|
printSelectionVMs = control.GetSelectedElements();
|
|
beWoWindow.Close();
|
|
};
|
|
control.ButtonCreateForSelectionClicked += () =>
|
|
{
|
|
printSelectionVMs.Add(control.combobox_elementList.SelectedItem as PrintSelectionVM);
|
|
beWoWindow.Close();
|
|
};
|
|
//control.ButtonCreateForAllClicked += () =>
|
|
//{
|
|
// printSelectionVMs = control.SelectAllElements();
|
|
// beWoWindow.Close();
|
|
//};
|
|
|
|
control.ButtonCancelClicked += () =>
|
|
{
|
|
beWoWindow.Close();
|
|
return;
|
|
};
|
|
|
|
beWoWindow.ShowDialog();
|
|
|
|
if(printSelectionVMs != null && printSelectionVMs.Count > 0)
|
|
{
|
|
if (printSelectionVMs[0].ObjectOid != null && printSelectionVMs[0].Table != null)
|
|
{
|
|
List<long> objectOids = new List<long>();
|
|
foreach (var p in printSelectionVMs)
|
|
{
|
|
objectOids.Add((long)p.ObjectOid);
|
|
}
|
|
|
|
string url = GenerateURL((long)templateVM.DataContract.DokumentvorlageOid, objectOids, (long)printSelectionVMs[0].Table);
|
|
|
|
BeWoUtils.NavigateToReportUri(url, Translator.Translate("Dokument mit ersetzten Platzhaltern"), () => { });
|
|
|
|
if(control.selectedFolder != null)
|
|
{
|
|
var objectOid = (control.combobox_elementList.SelectedItem as PrintSelectionVM).ObjectOid;
|
|
string text = ServiceFacade.DoOperationsServiceSync(s => s.ReplacePlaceholdersInTemplate(templateVM.DataContract, (long)objectOid, (control.combobox_elementList.SelectedItem as PrintSelectionVM).Table));
|
|
templateVM.Data = Encoding.ASCII.GetBytes(text);
|
|
UploadTemplateBasedDocument(control.selectedFolder.DataContract.BeWoFolderDC, templateVM.Name, (long)objectOid, templateVM);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UploadTemplateBasedDocument(BeWoFolderDC folder, string filename, long objectOid, DokumentvorlageVM dokumentvorlage)
|
|
{
|
|
try
|
|
{
|
|
FileAttachmentDC file = new FileAttachmentDC()
|
|
{
|
|
BeWoFolderOid = folder.BeWoFolderOid,
|
|
BinaryData = dokumentvorlage.Data,
|
|
Description = dokumentvorlage.Beschreibung,
|
|
FileAttachmentType = FileAttachmentType.NotSpecified,
|
|
FileAttachmentVersion = 1,
|
|
FileName = filename,
|
|
ObjectOid = objectOid,
|
|
ObjectTid = folder.ObjectTid,
|
|
InsertedBy = BeWoApp.LoggedOnEmployee.FirstName + BeWoApp.LoggedOnEmployee.LastName,
|
|
InsertedOn = DateTime.Now
|
|
};
|
|
|
|
ServiceFacade.DoOperationsServiceSync(s => s.InsertFileAttachment(file));
|
|
|
|
foreach (var node in DocumentsTreeView.Nodes)
|
|
{
|
|
UpdateFilesInFolder(file, folder, node);
|
|
}
|
|
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
}
|
|
|
|
private void UpdateFilesInFolder(FileAttachmentDC file, BeWoFolderDC folder, TreeListNode node)
|
|
{
|
|
var doctreeitem = node.Content as DocumentTreeItemVM;
|
|
if(doctreeitem.DataContract.ParentOid != null)
|
|
{
|
|
if (doctreeitem.DataContract.BeWoFolderDC != null)
|
|
{
|
|
foreach (var subnode in node.Nodes)
|
|
{
|
|
var sub = subnode.Content as DocumentTreeItemVM;
|
|
if (sub.DataContract.BeWoFolderDC.BeWoFolderOid == folder.BeWoFolderOid)
|
|
sub.DataContract.FilesInFolder.Add(file);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (node.Nodes.Count > 0)
|
|
{
|
|
foreach (var n in node.Nodes)
|
|
{
|
|
UpdateFilesInFolder(file, folder, n);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (node.Nodes.Count > 0)
|
|
{
|
|
foreach (var n in node.Nodes)
|
|
{
|
|
UpdateFilesInFolder(file, folder, n);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void TemplateDeleteButton_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var row = TemplateTreeView.SelectedRows[0] as DocumentTreeItemVM;
|
|
var selectedTemplate = this.datagrid_templates.GetFocusedRow() as DokumentvorlageVM;
|
|
if (selectedTemplate == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (MessageBox.Show("ACHTUNG: Das Löschen von Vorlagen kann nicht rückgängig gemacht werden!\nWollen Sie die Vorlage '" + selectedTemplate.Name + "' wirklich löschen?", "Löschen bestätigen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
|
|
{
|
|
return;
|
|
}
|
|
|
|
List<DokumentvorlageDC> listeMitDemDC = new List<DokumentvorlageDC>();
|
|
listeMitDemDC.Add(selectedTemplate.DataContract);
|
|
if (selectedTemplate.DataContract.DokumentvorlageOid != null)
|
|
{
|
|
ServiceFacade.DoOperationsServiceSync(s => s.DeleteTemplates(listeMitDemDC));
|
|
|
|
var gridItemsSource = this.datagrid_templates.ItemsSource as List<DokumentvorlageVM>;
|
|
datagrid_templates.ItemsSource = new List<DokumentvorlageVM>();
|
|
|
|
gridItemsSource.Remove(selectedTemplate);
|
|
this.datagrid_templates.ItemsSource = gridItemsSource;
|
|
}
|
|
}
|
|
|
|
public string GenerateURL(long vorlage, List<long> objectOids, long table)
|
|
{
|
|
string url = BeWoApp.SiteOfOrigin + "/ReportView.aspx?";
|
|
|
|
url += "&vorlage=" + vorlage;
|
|
|
|
url += "&obj=";
|
|
foreach (var oid in objectOids)
|
|
{
|
|
if (objectOids.IndexOf(oid) == objectOids.Count - 1)
|
|
url += oid;
|
|
else
|
|
url += oid + ",";
|
|
}
|
|
|
|
url += "&table=" + table;
|
|
url += "&type=" + Utils.EnumName(ReportTypes.VorlagenReport);
|
|
url = BeWoWpfUtils.GetHTMLEncodedURL(url);
|
|
|
|
return url;
|
|
}
|
|
|
|
private void TextBox_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
|
|
{
|
|
if (e.Key != Key.Enter)
|
|
return;
|
|
|
|
if (textbox_searchForFileName.Text.IsNullOrEmpty())
|
|
{
|
|
MessageBoxResult result = MessageBox.Show("Die Eingabe ist leer. Wollen Sie statt zu suchen alle vorhandenen Dateien ansehen?", "BeWoPlaner",
|
|
MessageBoxButton.YesNo, MessageBoxImage.Information);
|
|
if (result == MessageBoxResult.No)
|
|
return;
|
|
}
|
|
|
|
List<FileAttachmentDC> passendeFileAttachments = ServiceFacade.DoOperationsServiceSync(s => s.SearchForFiles(textbox_searchForFileName.Text));
|
|
|
|
List<SuchergebnisVM> suchergebnisse = new List<SuchergebnisVM>();
|
|
foreach (var file in passendeFileAttachments)
|
|
{
|
|
string path = BuildPath(file.BeWoFolderOid);
|
|
if (path.Equals("Alle Ordner"))
|
|
{
|
|
string table = TableIDToString(file.ObjectTid);
|
|
string objectName = ServiceFacade.DoOperationsServiceSync(s => s.GetObjectForFilePath(file.ObjectTid, file.ObjectOid));
|
|
path = table + "/" + objectName + "/" + path;
|
|
}
|
|
else
|
|
path = path.Remove(path.Length - 1);
|
|
|
|
suchergebnisse.Add(new SuchergebnisVM(file.FileName, path));
|
|
}
|
|
suchergebnisse = suchergebnisse.OrderBy(s => s.FileName).ToList();
|
|
var control = new Suchergebnis();
|
|
control.InitView(suchergebnisse);
|
|
|
|
var beWoWindow = new BeWoWindow
|
|
{
|
|
rootGroupBox = { Header = "Suchergebnis" },
|
|
Height = this.Height,
|
|
Width = 600,
|
|
MinWidth = 400,
|
|
WindowStartupLocation = WindowStartupLocation.CenterOwner,
|
|
GroupBoxContent = control,
|
|
Owner = BeWoApp.CurrentBeWo.MainWindow
|
|
};
|
|
|
|
List<PrintSelectionVM> printSelectionVMs = new List<PrintSelectionVM>();
|
|
|
|
control.ButtonOpenClicked += () =>
|
|
{
|
|
SuchergebnisVM selected = control.Selected;
|
|
string[] folders = selected.FilePath.Split('/');
|
|
TreeListNodeCollection nodes = DocumentsTreeView.Nodes;
|
|
foreach (var folder in folders)
|
|
{
|
|
if (folders[folders.Length - 1] == folder)
|
|
{
|
|
foreach (var node in nodes)
|
|
{
|
|
var c = node.Content as DocumentTreeItemVM;
|
|
foreach(var file in c.DataContract.FilesInFolder)
|
|
{
|
|
if (file.FileName.Equals(selected.FileName))
|
|
datagrid_documents.ItemsSource = c.DataContract.FilesInFolder;
|
|
}
|
|
}
|
|
beWoWindow.Close();
|
|
break;
|
|
}
|
|
|
|
if (nodes != null)
|
|
nodes = ExpandNodeWhichContainsFile(nodes, folder);
|
|
|
|
}
|
|
};
|
|
control.ButtonCancelClicked += () =>
|
|
{
|
|
beWoWindow.Close();
|
|
return;
|
|
};
|
|
|
|
beWoWindow.ShowDialog();
|
|
}
|
|
|
|
private TreeListNodeCollection ExpandNodeWhichContainsFile(TreeListNodeCollection nodes, string folder)
|
|
{
|
|
TreeListNodeCollection nextNodes = null;
|
|
foreach (var node in nodes)
|
|
{
|
|
var content = node.Content as DocumentTreeItemVM;
|
|
if (content.Name.Equals(folder))
|
|
{
|
|
node.IsExpanded = true;
|
|
if(node.Nodes != null)
|
|
nextNodes = node.Nodes;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return nextNodes;
|
|
}
|
|
|
|
private string BuildPath(long? folderOid)
|
|
{
|
|
string path = "";
|
|
|
|
if (folderOid != null)
|
|
{
|
|
var folder = ServiceFacade.DoOperationsServiceSync(s => s.GetFolderById((long)folderOid));
|
|
|
|
|
|
|
|
if (folder.ParentBeWoFolderOid != null)
|
|
path += BuildPath((long)folder.ParentBeWoFolderOid);
|
|
else
|
|
{
|
|
TableID tableID = folder.ObjectTid;
|
|
string objectName = ServiceFacade.DoOperationsServiceSync(s => s.GetObjectForFilePath(tableID, folder.ObjectOid));
|
|
string table = TableIDToString(tableID);
|
|
string t = path;
|
|
path = table + "/" + objectName + "/" + "Alle Ordner/" + t;
|
|
|
|
}
|
|
path += folder.Name + "/";
|
|
}
|
|
else
|
|
path += "Alle Ordner";
|
|
|
|
|
|
|
|
return path;
|
|
}
|
|
|
|
private string TableIDToString(TableID tableID)
|
|
{
|
|
string table = "";
|
|
switch(tableID)
|
|
{
|
|
case TableID.ApplicationUser: table = "Benutzer";break;
|
|
case TableID.SupportConcept: table = "Hilfepläne";break;
|
|
case TableID.Customer: table = "Klienten";break;
|
|
case TableID.Organisation: table = "Organisationen";break;
|
|
case TableID.Person: table = "Personen";break;
|
|
case TableID.Employee: table = "Mitarbeiter";break;
|
|
case TableID.Team: table = "Teams";break;
|
|
case TableID.UserGroup: table = "Benutzergruppen";break;
|
|
}
|
|
|
|
return table;
|
|
}
|
|
|
|
private void button_OpenUploadDocument_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var item = documents_treeview_control.SelectedItem as DocumentTreeItemVM;
|
|
|
|
if (item != null && item.DataContract != null && item.DataContract.BeWoFolderDC != null)
|
|
{
|
|
popup_UploadFiles.IsOpen = true;
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show(Translator.Translate("Bitte wählen Sie einen geeigneten Ordner aus!"), "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
|
|
}
|
|
|
|
private void popupedit_file_PopUpClick_1(object sender, RoutedEventArgs e)
|
|
{
|
|
|
|
var dlg = new OpenFileDialog();
|
|
|
|
if (dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
try
|
|
{
|
|
_UploadFileName = dlg.FileName;
|
|
_NormalFileName = dlg.SafeFileName;
|
|
popupedit_file.Text = dlg.SafeFileName;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
}
|
|
}
|
|
private void button_cancelFileUpload_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
popup_UploadFiles.IsOpen = false;
|
|
}
|
|
|
|
}
|
|
|
|
internal class DocumentRootNodeConfig
|
|
{
|
|
public TableID TableID { get; set; }
|
|
public String Title { get; set; }
|
|
public String IconName { get; set; }
|
|
public UserRightType DocumentRightNeeded { get; set; }
|
|
public IList<UserRightType> ListOfViewRightsNeeded { get; set; }
|
|
}
|
|
|
|
public class DeleteButtonVisibilityConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
if (BeWoApp.LoggedOnUser.HasRight(UserRightType.DocumentsDeleteAll))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public class EditButtonVisibilityConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
if (BeWoApp.LoggedOnUser.HasRight(UserRightType.DocumentsUploadAll))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
}
|