Sic.Framework-Nanjing-Baishi/MECF.Framework.UI.Core/Accounts/AccountViewModel.cs

566 lines
16 KiB
C#
Raw Normal View History

2023-04-13 11:51:03 +08:00
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Security.Policy;
using System.Windows;
using System.Windows.Controls;
using System.Xml;
using Aitex.Core.Account;
using Aitex.Core.RT.Log;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Util;
namespace MECF.Framework.UI.Core.Accounts
{
public class AccountViewModel
{
public class AccountInfo
{
public Account Account { get; set; }
public int No { get; set; }
public string AccountId { get { return Account.AccountId; } }
public bool IsEnabled { get { return Account.AccountStatus; } }
public string RealName { get { return Account.RealName; } }
public string Role { get { return Account.Role; } }
public string Department { get { return Account.Department; } }
public string LastLoginTime { get { return Account.LastLoginTime; } }
public string Description { get { return Account.Description; } }
public string Email { get { return Account.Email; } }
public string Telephone { get { return Account.Telephone; } }
}
public List<AccountInfo> AccountList { get; private set; }
/// <summary>
/// 总共创建的账号数目
/// </summary>
public int TotalAccountNum
{
get
{
return AccountList.Count;
}
}
/// <summary>
/// 账号有效的用户数
/// </summary>
public int EnabledAccountNum
{
get
{
int num = 0;
foreach (var item in AccountList)
{
if (item.IsEnabled) num++;
}
return num;
}
}
/// <summary>
/// Construction
/// </summary>
/// <param name="hideDisabledAccounts"></param>
public AccountViewModel(bool hideDisabledAccounts)
{
AccountList = new List<AccountInfo>();
var accounts = AccountClient.Instance.Service.GetAccountList();
if (accounts == null) return;
int num = 1;
foreach (var account in accounts.AccountList)
{
if (!account.AccountStatus && hideDisabledAccounts) continue;
AccountList.Add(new AccountInfo() { Account = account, No = num++ });
}
}
}
public class RolePermissionViewModel : INotifyPropertyChanged
{
#region Command
public DelegateCommand<object> SavePermissionCommand { get; set; }
#endregion
public SerializableDictionary<string, SerializableDictionary<string, ViewPermission>> Roles
{
get;
set;
}
ObservableCollection<string> roleNames = new ObservableCollection<string>();
public ObservableCollection<string> RoleNames
{
get
{
return roleNames;
}
set
{
roleNames = value;
}
}
public RolePermissionViewModel()
{
//cs 设置
loadPermissionFile();
Roles = AccountClient.Instance.Service.GetAllRolesPermission();
RoleNames.Clear();
foreach (string rolename in Roles.Keys)
{
RoleNames.Add(rolename);
}
}
public void SelectRoleChanged(string role)
{
CurrentRoleName = role;
BindAll();
}
public void InitialRolePermissionVM()
{
SavePermissionCommand = new DelegateCommand<object>(
param =>
{
try
{
//_xmlRecipeFormat.Save(recipePermissionFile);
bool suc = AccountClient.Instance.Service.SaveProcessViewPermission(_xmlRecipeFormat.InnerXml);
if (suc)
MessageBox.Show("保存菜单查看权限成功");
//Publisher.Notify(Subject.SendSaveSuccessMessage, "保存菜单查看权限成功");
}
catch (Exception ex)
{
LOG.Write(ex);
MessageBox.Show("保存菜单查看权限失败!");
//Publisher.Notify(Subject.SendWarningMessage, "保存菜单查看权限失败!");
}
},
param => { if (string.IsNullOrEmpty(CurrentRoleName))return false; return true; });
}
public CheckTreeViewModel ChamberAViewModel { get; set; }
//public CheckTreeViewModel ChamberBViewModel { get; set; }
//public CheckTreeViewModel ChamberCViewModel { get; set; }
//public CheckTreeViewModel ChamberDViewModel { get; set; }
public string CurrentRoleName { get; set; }
#region UI Logical
public
void loadPermissionFile()
{
ChamberAViewModel = new CheckTreeViewModel();
}
public static XmlDocument _xmlRecipeFormat = new XmlDocument();
public void BindAll()
{
}
#endregion
#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string proName)
{
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(proName));
}
#endregion
}
public class CheckTreeViewModel : INotifyPropertyChanged
{
public NodeViewModel Nodes { get; private set; }
public NodeInfo NodeInfo { get; private set; }
public CheckTreeViewModel()
{
NodeInfo = new NodeInfo();
NodeInfo.SelectedNodeChanged += (s, e) => RefreshCommands();
Nodes = new NodeViewModel(NodeInfo);
}
NodeViewModel GetOperationNode()
{
if (NodeInfo.SelectedNode == null)
return Nodes;
return NodeInfo.SelectedNode;
}
bool CheckSelection(object obj)
{
return NodeInfo.SelectedNode != null;
}
void RefreshCommands()
{
}
#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string proName)
{
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(proName));
}
#endregion
}
public class NodeInfo : INotifyPropertyChanged
{
NodeViewModel selectedNode;
int count;
public NodeViewModel SelectedNode
{
get { return selectedNode; }
set
{
if (selectedNode != value)
{
selectedNode = value;
OnSelectedNodeChanged();
OnPropertyChanged("SelectedNode");
}
}
}
public int Count
{
get { return count; }
private set
{
if (count != value)
{
count = value;
OnPropertyChanged("Count");
}
}
}
internal void SetCount(int newcount)
{
Count = newcount;
}
public event EventHandler SelectedNodeChanged;
protected virtual void OnSelectedNodeChanged()
{
if (SelectedNodeChanged != null)
SelectedNodeChanged(this, EventArgs.Empty);
}
#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string proName)
{
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(proName));
}
#endregion
}
public class NodeViewModel : INotifyPropertyChanged
{
/*
*
* */
const string DataName = "数据 ";
public XmlNode NodeXmlData { get; set; }
public string CurrentRoleName { get; set; }
static int DataCounter = 1;
public static string GetNextDataName()
{
return String.Concat(DataName, DataCounter++);
}
public NodeViewModel(NodeInfo info)
{
children = new ObservableCollection<NodeViewModel>();
NodeInfo = info;
CheckBoxCommand = new DelegateCommand<object>((p) => checkBoxSelect(p), param => { return true; });
}
private NodeViewModel(NodeViewModel parent, string name, string role)
: this(parent, name, false, null, role)
{
}
private NodeViewModel(NodeViewModel parent, string name, bool isSelected, XmlNode node, string role)
{
Parent = parent;
Name = name;
NodeInfo = parent.NodeInfo;
IsSelected = isSelected;
children = new ObservableCollection<NodeViewModel>();
SelectedNode = node;
CheckBoxCommand = new DelegateCommand<object>((p) => checkBoxSelect(p), param =>
{
return true;
});
CurrentRoleName = role;
}
public XmlNode SelectedNode = null;
void checkBoxSelect(object p)
{
if (SelectedNode != null)
{
CheckBox cb = p as CheckBox;
if (null != SelectedNode.Attributes["DenyRole"])
{
string denyroles = "," + SelectedNode.Attributes["DenyRole"].Value + ",";
string tagrole = "," + CurrentRoleName + ",";
if (cb.IsChecked.Value)
{
denyroles = denyroles.Replace(tagrole, ",");
SelectedNode.Attributes["DenyRole"].Value = denyroles.Trim(","[0]);
}
else
{
//没权限
if (denyroles.IndexOf(tagrole) < 0)
{
//本来有权限,现在要没权限
SelectedNode.Attributes["DenyRole"].Value = (denyroles + CurrentRoleName).Trim(","[0]);
}
}
}
else
{
if (cb.IsChecked.Value)
{
}
else
{
XmlAttribute xmlAttribute = RolePermissionViewModel._xmlRecipeFormat.CreateAttribute("DenyRole");
xmlAttribute.Value = CurrentRoleName;
SelectedNode.Attributes.Append(xmlAttribute);
}
}
//SelectedNode.Attributes["DenyRole"].Value = cb.IsChecked + "";
}
}
#region
string name;
bool isExpanded;
bool isSelected;
ObservableCollection<NodeViewModel> children;
#endregion
#region
public DelegateCommand<object> CheckBoxCommand { get; private set; }
public NodeInfo NodeInfo { get; private set; }
public NodeViewModel Parent { get; private set; }
public string Name
{
get
{
return name;
}
set
{
if (name != value)
{
name = value;
OnPropertyChanged("Name");
}
}
}
public bool IsExpanded
{
get
{
return isExpanded;
}
set
{
if (isExpanded != value)
{
isExpanded = value;
OnPropertyChanged("IsExpanded");
OnIsExpandedChanged();
}
}
}
public bool IsSelected
{
get { return isSelected; }
set
{
if (isSelected != value)
{
isSelected = value;
OnPropertyChanged("IsSelected");
OnIsSelectedChanged();
}
}
}
public ReadOnlyObservableCollection<NodeViewModel> Children
{
get
{
return new ReadOnlyObservableCollection<NodeViewModel>(children);
}
}
#endregion
#region
public void Remove()
{
//if (Parent != null)
//{
// Parent.children.Remove(this);
// RefreshInfoCount(-1);
//}
children.Clear();
RefreshInfoCount(-1);
}
public NodeViewModel Add(string name, XmlNode node, string role)
{
return Add(name, false, node, role);
}
public NodeViewModel Add(string name, bool ischecked, XmlNode node, string role)
{
//SelectedNode = node;
IsExpanded = true;
NodeViewModel nodeModel = new NodeViewModel(this, name, ischecked, node, role);
children.Insert(0, nodeModel);
RefreshInfoCount(1);
return nodeModel;
}
public void Append(string name, string role)
{
IsExpanded = true;
children.Add(new NodeViewModel(this, name, role));
RefreshInfoCount(1);
}
public void Rename()
{
Name = GetNextDataName();
}
public void MoveUp()
{
if (Parent != null)
{
var idx = Parent.children.IndexOf(this);
if (idx > 0)
{
Parent.children.RemoveAt(idx);
Parent.children.Insert(--idx, this);
}
IsSelected = true;
}
}
public void MoveDown()
{
if (Parent != null)
{
var idx = Parent.children.IndexOf(this);
if (idx < Parent.children.Count - 1)
{
Parent.children.RemoveAt(idx);
Parent.children.Insert(++idx, this);
}
IsSelected = true;
}
}
#endregion
#region
void RefreshInfoCount(int addition)
{
if (NodeInfo != null)
NodeInfo.SetCount(NodeInfo.Count + addition);
}
#endregion
#region
public event EventHandler IsExpandedChanged;
public event EventHandler IsSelectedChanged;
protected virtual void OnIsExpandedChanged()
{
if (IsExpandedChanged != null)
IsExpandedChanged(this, EventArgs.Empty);
}
protected virtual void OnIsSelectedChanged()
{
if (IsSelectedChanged != null)
IsSelectedChanged(this, EventArgs.Empty);
if (IsSelected)
NodeInfo.SelectedNode = this;
}
#endregion
#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string proName)
{
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(proName));
}
#endregion
}
}