static H权限()
{
H调试.记录明细("构造函数");
_文件路径 = "存储\\权限";
_所有数据 = (Tuple <List <M角色>, List <M用户> >)H序列化.二进制读取(_文件路径) ??
new Tuple <List <M角色>, List <M用户> >(new List <M角色>(), new List <M用户>());
__所有角色 = _所有数据.Item1;
__所有用户 = _所有数据.Item2;
if (__所有角色.Count == 0 || __所有用户.Count == 0)
{
H调试.记录明细("初始化");
__所有角色.Clear();
__所有用户.Clear();
var __管理员角色 = new M角色 {
称 = "管理员"
};
var __操作员角色 = new M角色 {
称 = "操作员"
};
__所有角色.Add(__管理员角色);
__所有角色.Add(__操作员角色);
__所有用户.Add(new M用户 {
帐号 = "admin", 密码 = "admin", 角色列表 = new List <M角色> {
__管理员角色
}
});
存储();
}
}
public H跟踪(string 信息, Dictionary <string, object> 参数, string __方法, string __文件, int __行号)
{
_开始时间 = Environment.TickCount;
_信息 = 信息;
_标识 = __标识序列号++;
H调试.记录提示(string.Format("[[{0} {1}", _标识, 信息), 参数, __方法, __文件, __行号);
}
public static M角色 查询角色(string 角色名)
{
H调试.记录明细("查询角色");
lock (_同步对象)
{
return(__所有角色.Find(q => q.称 == 角色名));
}
}
public static List <M角色> 查询所有角色()
{
H调试.记录明细("查询所有角色");
lock (_同步对象)
{
return(__所有角色);
}
}
public static M用户 查询用户(string 用户名)
{
H调试.记录明细("查询用户");
lock (_同步对象)
{
return(__所有用户.Find(q => q.帐号 == 用户名));
}
}
public static void 修改用户(M用户 用户)
{
H调试.记录明细("修改用户");
lock (_同步对象)
{
存储();
}
}
public void 设置上下文(string key, object value, [CallerMemberName] string __方法 = "", [CallerFilePath] string __文件 = "", [CallerLineNumber] int __行号 = 0)
{
_上下文[key] = value;
H调试.记录明细(_信息 + " 设置局部上下文", new Dictionary <string, object>
{
{ key, value }
}, __方法, __文件, __行号);
}
public static void 修改角色(M角色 角色)
{
H调试.记录明细("角色");
lock (_同步对象)
{
存储();
}
}
public static void 添加角色(M角色 角色)
{
H调试.记录明细("添加角色");
lock (_同步对象)
{
__所有角色.Add(角色);
存储();
}
}
public static void 除用户(M用户 用户)
{
H调试.记录明细("删除用户");
lock (_同步对象)
{
__所有用户.Remove(用户);
存储();
}
}
public void Dispose()
{
int 耗时 = Environment.TickCount - _开始时间;
if (_上下文.Count > 0)
{
刷新上下文();
}
H调试.记录提示(string.Format("]]{0} {1}[耗时: {2:f3}]", _标识 * -1, _信息, 耗时 / 1000.0));
}
public static void 除角色(M角色 角色)
{
H调试.记录明细("删除角色");
lock (_同步对象)
{
__所有用户.ForEach(q => q.角色列表.RemoveAll(v => v.称 == 角色.称));
__所有角色.Remove(角色);
存储();
}
}
public static void 验证(string 权限)
{
H调试.记录明细("验证");
var __用户 = 查询当前用户();
var 包含权限 = __用户.角色列表.Exists(q => q.权限列表.Exists(v => v.称 == 权限));
if (!包含权限)
{
throw new SecurityException(string.Format("无{0}的权限", 权限));
}
}
public static M用户 查询当前用户()
{
H调试.记录明细("查询当前用户");
var principal = Thread.CurrentPrincipal as GenericPrincipal;
if (principal == null)
{
throw new SecurityException("请先登录");
}
var __用户名 = principal.Identity.Name;
return(查询用户(__用户名));
}
public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)
{
if (input.MethodBase.IsDefined(typeof(NoLogAttribute), false) || input.MethodBase.Name.Contains("get_"))
{
return(getNext()(input, getNext));
}
var __title = new StringBuilder();
var __content = new StringBuilder();
if (input.Arguments.Count > 0)
{
__content.AppendFormat("[参数] {0}", input.MethodBase.IsDefined(typeof(NoLogArgumentsAttribute), false) ? "省略" : ArrayTojson(input.Arguments));
}
H调用顺序.Order++;
__title.Append("".PadLeft(H调用顺序.Order * 2, ' '));
__title.AppendFormat("[{0}]", H调用顺序.Order);
__title.AppendFormat("[{0}].{1}", input.MethodBase.DeclaringType, input.MethodBase.Name);
H调试.记录明细(__title.ToString(), __content.ToString(), null, null, 0);
__content.Clear();
IMethodReturn __结果 = getNext()(input, getNext);
if (__结果.Exception != null)
{
//var __frame = new System.Diagnostics.StackTrace(ex, 0, true).GetFrame(0);
__content.AppendFormat("[Error] {0}: {1}", __结果.Exception.GetType(), __结果.Exception.Message);
H调试.记录提示(__title.ToString(), __content.ToString(), null, null, 0);
}
else
{
bool __存在执行结果 = false;
if (__结果.ReturnValue != null && !input.MethodBase.IsDefined(typeof(NoLogReturnValueAttribute), false))
{
__content.AppendFormat("[返回值] {0}", Tojson(__结果.ReturnValue));
__存在执行结果 = true;
}
if (__结果.Outputs != null && __结果.Outputs.Count > 0 && !input.MethodBase.IsDefined(typeof(NoLogReturnValueAttribute), false))
{
__content.AppendFormat("[输出参数] {0}", Tojson(__结果.Outputs));
__存在执行结果 = true;
}
if (__存在执行结果)
{
H调试.记录明细(__title.ToString(), __content.ToString(), null, null, 0);
}
}
H调用顺序.Order--;
return(__结果);
}
internal static void 处理非UI线程(Exception ex)
{
H调试.记录异常(ex, "！！！处理非UI线程！！！");
_DotNetException = true;
if (自定义处理 != null)
{
if (自定义处理(ex))
{
return;
}
}
var __预计异常 = ex.GetBaseException() as M预计异常;
提示不可恢复异常(__预计异常 != null ? __预计异常.Message : "程序出错, 即将关闭", ex.ToString());
}
public static void 登录(string 帐号, string 密码)
{
H调试.记录明细("登录");
var 用户 = __所有用户.Find(q => q.帐号 == 帐号);
if (用户 == null)
{
throw new SecurityException("帐号不存在");
}
if (用户.密码 != 密码)
{
throw new SecurityException("密码错误");
}
IIdentity identity = new GenericIdentity(用户.帐号);
IPrincipal principal = new GenericPrincipal(identity, (from q in 用户.角色列表
select q.称).ToArray());
Thread.CurrentPrincipal = principal;
}
public static void 修改密码(string 原密码, string 新密码)
{
H调试.记录明细("修改密码");
var __用户 = 查询当前用户();
if (__用户.密码 == 原密码)
{
新密码 = 新密码.Trim();
if (新密码.Length == 0)
{
throw new SecurityException("请输入新密码");
}
__用户.密码 = 新密码;
修改用户(__用户);
}
else
{
throw new SecurityException("原密码不正确");
}
}
public static void 添加用户(M用户 用户)
{
H调试.记录明细("添加用户");
lock (_同步对象)
{
用户.帐号 = 用户.帐号.Trim();
用户.密码 = 用户.密码.Trim();
if (用户.帐号.Length == 0)
{
throw new SecurityException("请输入账号");
}
if (用户.密码.Length == 0)
{
throw new SecurityException("请输入密码");
}
if (__所有用户.Exists(q => q.帐号 == 用户.帐号))
{
throw new SecurityException("该账号已存在");
}
__所有用户.Add(用户);
存储();
}
}
public void 刷新上下文([CallerMemberName] string __方法 = "", [CallerFilePath] string __文件 = "", [CallerLineNumber] int __行号 = 0)
{
H调试.记录明细(_信息 + " 刷新局部上下文", _上下文, __方法, __文件, __行号);
}
public static void 注销()
{
H调试.记录明细("注销");
Thread.CurrentPrincipal = null;
}
private static void 输出(string __信息)
{
H调试.记录(__信息, TraceEventType.Verbose);
}
internal static void 处理UI线程(Exception ex, bool __未处理自动退出 = true)
{
if (自定义处理 != null)
{
if (自定义处理(ex))
{
return;
}
}
var __异常描述 = ex.ToString();
var __输入格式异常 = ex as M输入异常;
if (__输入格式异常 != null)
{
提示可恢复异常(__输入格式异常.类别, __输入格式异常.描述);
return;
}
var __Model验证异常 = ex as M验证异常;
if (__Model验证异常 != null)
{
提示可恢复异常(__Model验证异常.类别, __Model验证异常.描述);
return;
}
var __可恢复异常 = ex as M预计异常;
if (__可恢复异常 != null)
{
提示可恢复异常(__可恢复异常.类别, __可恢复异常.描述);
return;
}
if (ex is System.Security.SecurityException)
{
提示可恢复异常(ex.Message, string.Empty);
return;
}
if (ex is ApplicationException)
{
提示可恢复异常("错误", ex.Message);
return;
}
if (ex is NotImplementedException)
{
if (string.IsNullOrEmpty(ex.Message))
{
提示可恢复异常("错误", "功能未实现");
return;
}
提示可恢复异常("错误", ex.Message);
return;
}
H调试.记录异常(ex, "！！！处理UI线程！！！");
if (__未处理自动退出)
{
H调试.截屏();
提示不可恢复异常("出现未预计的错误，请将日志发送给开发人员", __异常描述);
Environment.Exit(0);
}
提示可恢复异常("错误", "出现未预计的错误，请将日志发送给开发人员");
}
public static List <M用户> 查询所有用户()
{
H调试.记录明细("查询所有用户");
return(__所有用户);
}
