Asp.net MVC系列教程7——创建与登录用户相关的接口和实现类

作者 Guanghui Wang 日期 2017-02-19
c#

简述

本文转自http://yuangang.cnblogs.com并加以整理。 今天我们创建几个与登录用户相关的数据表的接口和实现类

索引

Asp.net MVC项目系列教程

项目开始

一、新建登录用户类Account

之前lesson5我们登录验证直接返回了管理员实体类SYS_USER，但是在实际的后台操作验证中，我们并不需要SYS_USER的许多属性，同时我们需要它的一些扩展属性，我们来新建一个管理员类，来具体的描述这个管理员，我们在Service类库下面新建一个管理类Account.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
using System.Collections.Generic;

namespace Service
{
    /// <summary>
    /// 通用用户登录类，简单信息
    /// </summary>
    public class Account
    {
        #region Attribute
        /// <summary>
        /// 主键
        /// </summary>
        public int Id { get; set; }
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 登录的用户名
        /// </summary>
        public string LogName { get; set; }
        /// <summary>
        /// 登录密码
        /// </summary>
        public string PassWord { get; set; }
        /// <summary>
        /// 是否管理员
        /// </summary>
        public bool IsAdmin { get; set; }
        /// <summary>
        /// 用户头像
        /// </summary>
        public string Face_Img { get; set; }
        /// <summary>
        /// 用户主部门
        /// </summary>
        public Domain.SYS_DEPARTMENT DptInfo { get; set; }
        /// <summary>
        /// 用户所在部门集合
        /// </summary>
        public List<Domain.SYS_DEPARTMENT> Dpt { get; set; }
        /// <summary>
        /// 权限集合
        /// </summary>
        public List<Domain.SYS_PERMISSION> Permissions { get; set; }
        /// <summary>
        /// 角色的集合
        /// </summary>
        public List<Domain.SYS_ROLE> Roles { get; set; }
        /// <summary>
        /// 用户岗位集合
        /// </summary>
        public List<Domain.SYS_POST_USER> PostUser { get; set; }
        /// <summary>
        /// 用户可操作的模块集合
        /// </summary>
        public List<Domain.SYS_MODULE> Modules { get; set; }
        #endregion
    }
}

二、修改我们的用户管理接口IUserManage

修改用户管理接口IService/SysManage/IUserManage.cs. 添加几个方法：根据用户ID获取本职部门名称、 删除用户、根据用户构造用户基本信息、从Cookie中获取用户信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/// <summary>
/// 根据用户ID获取本职部门名称
/// </summary>
string GetUserDptName(int id);
/// <summary>
/// 删除用户
/// </summary>
bool Remove(int userId);
/// <summary>
/// 根据用户构造用户基本信息
/// </summary>
Account GetAccountByUser(Domain.SYS_USER user);
/// <summary>
/// 从Cookie中获取用户信息
/// </summary>
Account GetAccountByCookie();

三、我们分别创建几个关联表的接口和实现类

创建SYS_USERINFO（用户档案）、SYS_USER_ROLE（用户角色）、SYS_USER_PERMISSION（用户权限）、SYS_POST_USER（用户岗位）、SYS_USER_DEPARTMENT（用户部门）、SYS_PERMISSION（权限表）、SYS_DEPARTMENT（部门表）、SYS_MODULE（模块表）的接口和实现类

IUserInfoManage、UserInfoManage

1
2
3
4
5
6
7
8
9
10
11
12
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Service.IService
{
    public interface IUserInfoManage : IRepository<Domain.SYS_USERINFO>
    {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.ServiceImp
{
    /// <summary>
    /// Service层用户拓展信息接口
    /// </summary>
    public class UserInfoManage : RepositoryBase<Domain.SYS_USERINFO>, IService.IUserInfoManage
    {
    }
}

IUserRoleManage、UserRoleManage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Service.IService
{
    /// <summary>
    /// Service层用户与角色关系接口
    /// </summary>
    public interface IUserRoleManage : IRepository<Domain.SYS_USER_ROLE>
    {
        /// <summary>
        /// 设置用户角色
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <param name="roleId">角色ID字符串</param>
        /// <returns></returns>
        bool SetUserRole(int userId, string roleId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.ServiceImp
{
    /// <summary>
    /// Service层用户与角色关系接口
    /// </summary>
    public class UserRoleManage : RepositoryBase<Domain.SYS_USER_ROLE>, IService.IUserRoleManage
    {
        /// <summary>
        /// 设置用户角色
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <param name="roleId">角色ID字符串,连接</param>
        public bool SetUserRole(int userId, string roleId)
        {
            try
            {
                //1、删除用户角色
                this.Delete(p => p.FK_USERID == userId);
                //2、设置当前用户的角色
                if (string.IsNullOrEmpty(roleId)) return true;
                foreach (var entity in roleId.Split(',').Select(t => new Domain.SYS_USER_ROLE()
                {
                    FK_USERID = userId,
                    FK_ROLEID = int.Parse(t)
                }))
                {
                    this.dbSet.Add(entity);
                }
                return this.Context.SaveChanges() > 0;
            }
            catch (Exception e) { throw e; }
        }
    }
}

IPermissionManage、PermissionManage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.IService
{
    /// <summary>
    /// Service 授权验证模块对应接口
    /// </summary>
    public interface IPermissionManage : IRepository<Domain.SYS_PERMISSION>
    {
        /// <summary>
        /// 根据系统ID获取所有模块的权限ID集合
        /// </summary>
        List<int> GetPermissionIdBySysId(string sysId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Data.SqlClient;
using System.Linq;
using System.Text;

namespace Service.ServiceImp
{
    /// <summary>
    /// Service 授权模块关系处理类
    /// </summary>
    public class PermissionManage : RepositoryBase<Domain.SYS_PERMISSION>, IService.IPermissionManage
    {
        /// <summary>
        /// 根据系统ID获取所有模块的权限ID集合
        /// </summary>
        public List<int> GetPermissionIdBySysId(string sysId)
        {
            try
            {
                string sql = "select p.id from sys_permission p where exists(select 1 from sys_module t where t.fk_belongsystem=@sysid and t.id=p.moduleid)";
                DbParameter para = new SqlParameter("@sysid", sysId);
                return this.SelectBySql<int>(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
    }
}

IUserPermissionManage、UserPermissionManage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.IService
{
    /// <summary>
    /// Service层用户授权接口
    /// </summary>
    public interface IUserPermissionManage : IRepository<Domain.SYS_USER_PERMISSION>
    {
        /// <summary>
        /// 设置用户权限
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <param name="newper">权限字符串</param>
        /// <param name="sysId">系统ID</param>
        /// <returns></returns>
        bool SetUserPermission(int userId, string newper, string sysId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Service.IService;

namespace Service.ServiceImp
{
    /// <summary>
    /// Service层用户授权接口
    /// </summary>
    public class UserPermissionManage : RepositoryBase<Domain.SYS_USER_PERMISSION>, IUserPermissionManage
    {
        IPermissionManage PermissionManage { get; set; }
        /// <summary>
        /// 保存用户权限
        /// </summary>
        public bool SetUserPermission(int userId, string newper, string sysId)
        {
            try
            {
                //1、获取当前系统的模块ID集合
                var permissionId = this.PermissionManage.GetPermissionIdBySysId(sysId).Cast<int>().ToList();
                //2、获取用户权限，是否存在，存在即删除
                if (this.IsExist(p => p.FK_USERID == userId && permissionId.Any(e => e == p.FK_PERMISSIONID)))
                {
                    //3、删除用户权限
                    this.Delete(p => p.FK_USERID == userId && permissionId.Any(e => e == p.FK_PERMISSIONID));
                }
                //4、添加用户权限
                var str = newper.Trim(',').Split(',');
                foreach (var per in str.Select(t => new Domain.SYS_USER_PERMISSION()
                {
                    FK_USERID = userId,
                    FK_PERMISSIONID = int.Parse(t)
                }))
                {
                    this.dbSet.Add(per);
                }
                //5、Save
                return this.Context.SaveChanges() > 0;
            }
            catch (Exception e) { throw e; }
        }
    }
}

IPostUserManage、PostUserManage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.IService
{
    /// <summary>
    /// 岗位用户关系业务接口
    /// </summary>
    public interface IPostUserManage : IRepository<Domain.SYS_POST_USER>
    {
        /// <summary>
        /// 根据岗位ID获取人员集合，可传递多个岗位ID
        /// </summary>
        List<Domain.SYS_USER> GetUserListByPostId(string postId);
        /// <summary>
        /// 根据人员ID获取岗位集合，可传递多个
        /// </summary>
        List<Domain.SYS_POST> GetPostListByUserId(string userId);
        /// <summary>
        /// 添加岗位人员关系
        /// </summary>
        /// <param name="userId">人员ID</param>
        /// <param name="postId">岗位ID集合</param>
        /// <returns></returns>
        bool SavePostUser(int userId, string postId);
        /// <summary>
        /// 根据岗位集合获取岗位名称，部门-岗位模式        
        /// </summary>
        dynamic GetPostNameBySysPostUser(ICollection<Domain.SYS_POST_USER> collection);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.ServiceImp
{
    /// <summary>
    /// 岗位人员关系业务实现类
    /// </summary>
    public class PostUserManage : RepositoryBase<Domain.SYS_POST_USER>, IService.IPostUserManage
    {
        /// <summary>
        /// 根据岗位ID获取人员列表
        /// </summary>
        public List<Domain.SYS_USER> GetUserListByPostId(string postId)
        {
            try
            {
                string sql = @"select * from sys_user t where exists(select u.fk_userid from sys_post_user u
                                inner join sys_post_department p
                                on u.fk_post_departmentid=p.id
                                where t.id=u.fk_userid and p.fk_post_id in (" + postId + ")  group by u.fk_userid)";
                return this.SelectBySql<Domain.SYS_USER>(sql);
            }
            catch (Exception e) { throw e.InnerException; }
        }
        /// <summary>
        /// 根据用户ID获取所持有的岗位集合
        /// </summary>
        public List<Domain.SYS_POST> GetPostListByUserId(string userId)
        {
            return this.LoadAll(p => userId.Contains(p.FK_USERID.ToString())).Select(p => p.SYS_POST_DEPARTMENT.SYS_POST).ToList();
        }

        /// <summary>
        /// 添加岗位人员关系
        /// </summary>
        /// <param name="userId">人员ID</param>
        /// <param name="postId">岗位ID集合</param>
        /// <returns></returns>
        public bool SavePostUser(int userId, string postId)
        {
            try
            {
                if (this.IsExist(p => p.FK_USERID == userId))
                {
                    //存在之后再对比是否一致
                    var oldCount = this.LoadAll(p => p.FK_USERID == userId).Select(p => p.FK_POST_DEPARTMENTID).ToList().Cast<int>().ToList();
                    var newpostId = postId.Trim(',').Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(p => int.Parse(p)).ToList();
                    if (oldCount.Count == newpostId.Count && oldCount.All(newpostId.Contains)) return true;
                    //删除原有关系
                    this.Delete(p => p.FK_USERID == userId);
                }
                if (!string.IsNullOrEmpty(postId))
                {
                    //添加现有关系
                    var list = postId.Split(',').Select(item => new Domain.SYS_POST_USER()
                    {
                        FK_USERID = userId,
                        FK_POST_DEPARTMENTID = int.Parse(item)
                    }).ToList();
                    return this.SaveList(list) > 0;
                }
                return true;
            }
            catch (Exception e) { throw e.InnerException; }
        }

        /// <summary>
        /// 根据岗位集合获取岗位名称，部门-岗位模式        
        /// </summary>
        public dynamic GetPostNameBySysPostUser(ICollection<Domain.SYS_POST_USER> collection)
        {
            //岗位部门关系ID集合
            string post_departmentid = collection.Select(p => p.FK_POST_DEPARTMENTID).Aggregate(string.Empty, (current, t) => current + "'" + t + "',").TrimEnd(',');
            try
            {
                string sql = @"select d.name+'-'+p.postname as postname,s.id from sys_department d inner join
                        sys_post_department s on d.id=s.fk_department_id
                        inner join sys_post p on p.id=s.fk_post_id
                        where s.id in (" + post_departmentid + ")";
                return this.ExecuteSqlQuery(sql);
            }
            catch (Exception e) { throw e.InnerException; }
        }
    }
}

IUserDepartmentManage、UserDepartmentManage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.IService
{
    /// <summary>
    /// 用户部门关系业务接口
    /// </summary>
    public interface IUserDepartmentManage : IRepository<Domain.SYS_USER_DEPARTMENT>
    {
        /// <summary>
        /// 根据部门ID获取当前部门的所有用户集合
        /// </summary>
        List<Domain.SYS_USER> GetUserListByDptId(List<string> dptId);
        /// <summary>
        /// 根据用户ID获取所在的部门集合
        /// </summary>
        List<Domain.SYS_DEPARTMENT> GetDptListByUserId(int userId);
        /// <summary>
        /// 保存用户部门关系
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <param name="dptId">部门ID集合</param>
        /// <returns></returns>
        bool SaveUserDpt(int userId, string dptId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.ServiceImp
{
    /// <summary>
    /// 用户部门关系业务实现类
    /// </summary>
    public class UserDepartmentManage : RepositoryBase<Domain.SYS_USER_DEPARTMENT>, IService.IUserDepartmentManage
    {
        /// <summary>
        /// 根据部门ID获取当前部门的所有用户ID集合
        /// </summary>
        public List<Domain.SYS_USER> GetUserListByDptId(List<string> dptId)
        {
            return this.LoadAll(p => dptId.Contains(p.DEPARTMENT_ID)).Select(p => p.SYS_USER).ToList();
        }
        /// <summary>
        /// 根据用户ID获取所在的部门ID集合
        /// </summary>
        public List<Domain.SYS_DEPARTMENT> GetDptListByUserId(int userId)
        {
            return this.LoadAll(p => p.USER_ID == userId).Select(p => p.SYS_DEPARTMENT).ToList();
        }

        /// <summary>
        /// 保存用户部门关系
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <param name="dptId">部门ID集合</param>
        public bool SaveUserDpt(int userId, string dptId)
        {
            try
            {
                //原始部门人员关系是否与当前设置一致，不一致重新构造
                if (this.IsExist(p => p.USER_ID == userId))
                {
                    //存在之后再对比是否一致
                    var oldCount = this.LoadAll(p => p.USER_ID == userId && dptId.Contains(p.DEPARTMENT_ID)).Select(p => p.DEPARTMENT_ID).ToList();
                    var newdptid = dptId.Split(',').OrderBy(c => c).ToList();
                    if (oldCount.Count == newdptid.Count && oldCount.All(newdptid.Contains)) return true;
                    //删除原有关系
                    this.Delete(p => p.USER_ID == userId);
                }
                if (!string.IsNullOrEmpty(dptId))
                {
                    //添加现有关系
                    var list = dptId.Split(',').Select(item => new Domain.SYS_USER_DEPARTMENT()
                    {
                        DEPARTMENT_ID = item,
                        USER_ID = userId
                    }).ToList();
                    return this.SaveList(list) > 0;
                }
                return true;
            }
            catch (Exception e) { throw e.InnerException; }
        }
    }
}

IDepartmentManage、DepartmentManage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.IService
{
    /// <summary>
    /// Service层部门管理接口
    /// </summary>
    public interface IDepartmentManage : IRepository<Domain.SYS_DEPARTMENT>
    {
        /// <summary>
        /// 递归部门列表，返回按级别排序
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        List<Domain.SYS_DEPARTMENT> RecursiveDepartment(List<Domain.SYS_DEPARTMENT> list);

        /// <summary>
        /// 根据部门ID递归部门列表，返回子部门+本部门的对象集合
        /// </summary>
        List<Domain.SYS_DEPARTMENT> RecursiveDepartment(string parentId);
        /// <summary>
        /// 自动创建部门编号
        /// </summary>
        string CreateCode(string parentCode);

        /// <summary>
        /// 部门是否存在下级部门
        /// </summary>
        bool DepartmentIsExists(string idlist);

        /// <summary>
        /// 根据部门ID获取部门名称，不存在返回空
        /// </summary>
        string GetDepartmentName(string id);
        /// <summary>
        /// 显示错层方法
        /// </summary>
        object GetDepartmentName(string name, decimal? level);
        /// <summary>
        /// 获取部门父级列表
        /// </summary>
        System.Collections.IList GetDepartmentByDetail();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
using Common.JsonHelper;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.ServiceImp
{
    /// <summary>
    /// Service层部门管理
    /// </summary>
    public class DepartmentManage : RepositoryBase<Domain.SYS_DEPARTMENT>, IService.IDepartmentManage
    {
        /// <summary>
        /// 自动创建部门编号
        /// <param name="parentId">上级部门ID 注：ID不是Code，数据表已改</param>
        /// </summary>
        public string CreateCode(string parentId)
        {
            string _strCode = string.Empty;

            #region 验证上级部门code是否为空，为空返回，第一级部门的Code
            if (string.IsNullOrEmpty(parentId))
            {
                //注意：Oracle存储值为空=null MsSql 空=空 null=null
                var query = this.LoadAll(p => p.PARENTID == null || p.PARENTID == "").OrderBy(p => p.CODE).ToList();
                if (!query.Any())
                {
                    return "001";
                }
                //按照之前的逻辑，查漏补缺
                for (int i = 1; i <= query.Count; i++)
                {
                    string code = query[i - 1].CODE;
                    if (string.IsNullOrEmpty(code))
                    {
                        return FormatCode(i);
                    }
                    if (i != int.Parse(code))
                    {
                        return FormatCode(i);
                    }
                }
                return FormatCode(query.Count + 1);
            }
            #endregion

            #region 上级部门不为空,返回当前上级部门下的部门Code

            /* *根据部门编号获取下级部门 查询条件为：
             * 1.下级部门编号长度=当前部门编号+3
             * 2.下级部门上级部门ID=当前部门ID
             * */
            var parentDpt = this.Get(p => p.ID == parentId);
            if (parentDpt != null)//上级部门存在
            {
                //查询同等级部门下的所有数据
                var queryable = this.LoadAll(p => p.CODE.Length == parentDpt.CODE.Length + 3 && p.PARENTID == parentId).OrderBy(p => p.CODE).ToList();
                if (queryable.Any())
                {
                    //需要验证是否存在编号缺失的情况 方法:遍历下级部门列表，
                    //用部门编号去掉上级部门编号，然后转化成数字和for循环的索引进行对比,遇到第一个不相等时，返回此编号，并跳出循环
                    for (int i = 1; i <= queryable.Count; i++)
                    {
                        string _code = queryable[i - 1].CODE;
                        _code = _code.Substring(parentDpt.CODE.Length);
                        int _intCode = 0;
                        Int32.TryParse(_code, out _intCode);
                        //下级部门编号中不存在
                        if (i != _intCode)
                        {
                            //返回此编号,并退出循环
                            _strCode = parentDpt.CODE + FormatCode(i);
                            return _strCode;
                        }
                    }
                    //不存在编号缺失情况
                    _strCode = parentDpt.CODE + FormatCode(queryable.Count + 1);
                }
                else
                {
                    _strCode = parentDpt.CODE + FormatCode(1);
                    return _strCode;
                }
            }//上级部门不存在，返回空，这种情况基本不会出现
            #endregion

            return _strCode;
        }
        /// <summary>
        /// 功能描述:根据传入的数字 返回补码后的3位部门编号
        /// </summary>
        public string FormatCode(int dptCode)
        {
            try
            {
                string _strCode = string.Empty;
                //<=9 一位数
                if (dptCode <= 9 && dptCode >= 1)
                {
                    return "00" + dptCode;
                }
                //<=99 两位数
                else if (dptCode <= 99 && dptCode > 9)
                {
                    return "0" + dptCode;
                }
                //<==999 三位数
                else if (dptCode <= 999 && dptCode > 99)
                {
                    return _strCode;
                }
                return string.Empty;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 验证当前删除的部门是否存在下级部门
        /// </summary>
        public bool DepartmentIsExists(string idlist)
        {
            return this.IsExist(p => idlist.Contains(p.PARENTID));
        }

        /// <summary>
        /// 递归部门列表，返回排序后的对象集合
        /// </summary>
        public List<Domain.SYS_DEPARTMENT> RecursiveDepartment(List<Domain.SYS_DEPARTMENT> list)
        {
            var result = new List<Domain.SYS_DEPARTMENT>();
            if (list.Count > 0)
            {
                ChildDepartment(list, result, null);
            }
            return result;
        }

        /// <summary>
        /// 根据部门ID递归部门列表，返回子部门+本部门的对象集合
        /// </summary>
        public List<Domain.SYS_DEPARTMENT> RecursiveDepartment(string parentId)
        {
            //原始数据
            var list = this.LoadAll(null);
            //新数据
            var result = new List<Domain.SYS_DEPARTMENT>();
            if (list.Any())
            {
                result.AddRange(list.Where(p => p.ID == parentId).ToList());
                if (!string.IsNullOrEmpty(parentId))
                    ChildDepartment(list.ToList(), result, parentId);
                else
                    ChildDepartment(list.ToList(), result, null);//oracle使用null sql使用空
            }
            return result;
        }

        private void ChildDepartment(List<Domain.SYS_DEPARTMENT> newlist, List<Domain.SYS_DEPARTMENT> list, string id)
        {
            var result = newlist.Where(p => p.PARENTID == id).OrderBy(p => p.CODE).ThenBy(p => p.SHOWORDER).ToList();
            if (result.Any())
            {
                for (int i = 0; i < result.Count(); i++)
                {
                    list.Add(result[i]);
                    ChildDepartment(newlist, list, result[i].ID);
                }
            }
        }

        /// <summary>
        /// 根据部门ID获取部门名称，不存在返回空
        /// </summary>
        public string GetDepartmentName(string id)
        {
            var query = this.LoadAll(p => p.ID == id);
            if (query == null || !query.Any())
                return "";
            return query.First().NAME;
        }

        /// <summary>
        /// 显示错层方法
        /// </summary>
        public object GetDepartmentName(string name, decimal? level)
        {
            if (level > 1)
            {
                string nbsp = "&nbsp;&nbsp;";
                for (int i = 0; i < level; i++)
                {
                    nbsp += "&nbsp;&nbsp;";
                }
                name = nbsp + "|--" + name;
            }
            return name;
        }

        /// <summary>
        /// 获取父级列表
        /// </summary>
        public IList GetDepartmentByDetail()
        {
            var list = RecursiveDepartment(this.LoadAll(null).ToList())
                .Select(p => new
                {
                    id = p.ID,
                    code = p.CODE,
                    name = GetDepartmentName(p.NAME, p.BUSINESSLEVEL)
                }).ToList();

            return JsonConverter.JsonClass(list);
        }
    }
}

IModuleManage、ModuleManage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.IService
{
    /// <summary>
    /// Service模型处理接口
    /// </summary>
    public interface IModuleManage : IRepository<Domain.SYS_MODULE>
    {
        /// <summary>
        /// 获取用户权限模块集合
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <param name="permission">用户授权集合</param>
        /// <param name="siteId">站点ID</param>
        /// <returns></returns>
        List<Domain.SYS_MODULE> GetModule(int userId, List<Domain.SYS_PERMISSION> permission, string siteId);
        /// <summary>
        /// 递归模块列表，返回按级别排序
        /// </summary>
        List<Domain.SYS_MODULE> RecursiveModule(List<Domain.SYS_MODULE> list);

        /// <summary>
        /// 批量变更当前模块下其他模块的级别
        /// </summary>
        bool MoreModifyModule(int moduleId, int levels);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
using Common.JsonHelper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Service.ServiceImp
{
    /// <summary>
    /// Service模型处理类
    /// </summary>
    public class ModuleManage : RepositoryBase<Domain.SYS_MODULE>, IService.IModuleManage
    {
        /// <summary>
        /// 获取用户权限模块集合
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <param name="permission">用户授权集合</param>
        /// <param name="siteId">站点ID</param>
        /// <returns></returns>
        public List<Domain.SYS_MODULE> GetModule(int userId, List<Domain.SYS_PERMISSION> permission, string siteId)
        {
            //返回模块
            var retmodule = new List<Domain.SYS_MODULE>();
            var permodule = new List<Domain.SYS_MODULE>();
            //权限转模块
            if (permission != null)
            {
                permodule.AddRange(permission.Select(p => p.SYS_MODULE));
                //去重
                permodule = permodule.Distinct(new ModuleDistinct()).ToList();
            }
            //检索显示与系统
            //permodule = permodule.Where(p => p.ISSHOW == 1 && p.FK_BELONGSYSTEM.ToString() == siteId).ToList();
            //商城系统融入本系统不再区分系统
            permodule = permodule.Where(p => p.ISSHOW == 1).ToList();
            //构造上级导航模块
            //var prevModule = this.LoadListAll(p => p.FK_BELONGSYSTEM.ToString() == siteId);
            //商城系统融入本系统不再区分系统
            var prevModule = this.LoadListAll(null);
            //反向递归算法构造模块带上级上上级模块
            if (permodule.Count > 0)
            {
                foreach (var item in permodule)
                {
                    RecursiveModule(prevModule, retmodule, item.PARENTID);
                    retmodule.Add(item);
                }
            }
            //去重
            retmodule = retmodule.Distinct(new ModuleDistinct()).ToList();
            //返回模块集合
            return retmodule.OrderBy(p => p.LEVELS).ThenBy(p => p.SHOWORDER).ToList();
        }

        /// <summary>
        /// 反向递归模块集合，可重复模块数据，最后去重
        /// </summary>
        /// <param name="PrevModule">总模块</param>
        /// <param name="retmodule">返回模块</param>
        /// <param name="parentId">上级ID</param>
        private void RecursiveModule(List<Domain.SYS_MODULE> PrevModule, List<Domain.SYS_MODULE> retmodule, int? parentId)
        {
            var result = PrevModule.Where(p => p.ID == parentId);
            if (result != null)
            {
                foreach (var item in result)
                {
                    retmodule.Add(item);
                    RecursiveModule(PrevModule, retmodule, item.PARENTID);
                }
            }
        }

        /// <summary>
        /// 递归模块列表，返回按级别排序
        /// </summary>
        public List<Domain.SYS_MODULE> RecursiveModule(List<Domain.SYS_MODULE> list)
        {
            List<Domain.SYS_MODULE> result = new List<Domain.SYS_MODULE>();
            if (list != null && list.Count > 0)
            {
                ChildModule(list, result, 0);
            }
            return result;
        }
        /// <summary>
        /// 递归模块列表
        /// </summary>
        private void ChildModule(List<Domain.SYS_MODULE> list, List<Domain.SYS_MODULE> newlist, int parentId)
        {
            var result = list.Where(p => p.PARENTID == parentId).OrderBy(p => p.LEVELS).OrderBy(p => p.SHOWORDER).ToList();
            if (result.Count() > 0)
            {
                for (int i = 0; i < result.Count(); i++)
                {
                    newlist.Add(result[i]);
                    ChildModule(list, newlist, result[i].ID);
                }
            }
        }

        /// <summary>
        /// 批量变更下级模块的级别
        /// </summary>
        public bool MoreModifyModule(int moduleId, int levels)
        {
            //根据当前模块ID获取下级模块的集合
            var ChildModule = this.LoadAll(p => p.PARENTID == moduleId).ToList();
            if (ChildModule.Any())
            {
                foreach (var item in ChildModule)
                {
                    item.LEVELS = levels + 1;
                    this.Update(item);
                    MoreModifyModule(item.ID, item.LEVELS);
                }
            }
            return true;
        }

        /// <summary>
        /// 获取模板列表
        /// </summary>
        public dynamic LoadModuleInfo(int id)
        {
            return JsonConverter.JsonClass(this.LoadAll(p => p.PARENTID == id).OrderBy(p => p.ID).Select(p => new { p.ID, p.NAME }).ToList());
        }
    }
    /// <summary>
    /// 模型去重，非常重要
    /// </summary>
    public class ModuleDistinct : IEqualityComparer<Domain.SYS_MODULE>
    {
        public bool Equals(Domain.SYS_MODULE x, Domain.SYS_MODULE y)
        {
            return x.ID == y.ID;
        }

        public int GetHashCode(Domain.SYS_MODULE obj)
        {
            return obj.ToString().GetHashCode();
        }
    }
}

四、修改UserManage实现类

为UserManage增加多个属性，后面通过Spring注入。最后增加权限去重class，暂时也放在UserManage类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
using Service.IService;
using System.Linq;
using Domain;
using System;
using Common.JsonHelper;
using System.Collections.Generic;

namespace Service.ServiceImp
{
    public class UserManage : RepositoryBase<SYS_USER>, IUserManage
    {
        IDepartmentManage DepartmentManage { get; set; }
        IUserDepartmentManage UserDepartmentManage { get; set; }
        IUserInfoManage UserInfoManage { get; set; }
        IUserRoleManage UserRoleManage { get; set; }
        IUserPermissionManage UserPermissionManage { get; set; }
        IPostUserManage PostUserManage { get; set; }
        IPermissionManage PermissionManage { get; set; }

        /// <summary>
        /// 管理用户登录验证
        /// </summary>
        /// <param name="userAccount">用户名</param>
        /// <param name="password">加密密码（AES）</param>
        /// <returns></returns>
        public SYS_USER UserLogin(string userAccount, string password)
        {
            var entity = this.Get(p => p.ACCOUNT == userAccount);

            //因为我们用的是AES的动态加密算法，也就是没有统一的密钥，那么两次同样字符串的加密结果是不一样的，所以这里要通过解密来匹配
            //而不能通过再次加密输入的密码来匹配
            if (entity != null && new Common.CryptHelper.AESCrypt().Decrypt(entity.PASSWORD) == password)
            {
                return entity;
            }
            return null;
        }

        /// <summary>
        /// 是否超级管理员
        /// </summary>
        public bool IsAdmin(int userId)
        {
            //通过用户ID获取角色
            SYS_USER entity = this.Get(p => p.ID == userId);
            if (entity == null) return false;
            var roles = entity.SYS_USER_ROLE.Select(p => new SYS_ROLE
            {
                ID = p.SYS_ROLE.ID
            });
            return roles.ToList().Any(item => item.ID == Common.Enums.ClsDic.DicRole["超级管理员"]);
        }

        /// <summary>
        /// 根据用户ID获取用户名
        /// </summary>
        /// <param name="Id">用户ID</param>
        /// <returns></returns>
        public string GetUserName(int Id)
        {
            var query = this.LoadAll(c => c.ID == Id);
            if (query == null || !query.Any())
            {
                return "";
            }
            return query.First().NAME;
        }

        /// <summary>
        /// 根据用户ID获取部门名称
        /// </summary>
        public string GetUserDptName(int id)
        {
            if (id <= 0)
                return "";
            var dptid = this.Get(p => p.ID == id).DPTID;
            return this.DepartmentManage.Get(p => p.ID == dptid).NAME;
        }

        /// <summary>
        /// 根据用户ID删除用户相关记录
        /// 删除原则：1、删除用户档案
        ///           2、删除用户角色关系
        ///           3、删除用户权限关系
        ///           4、删除用户岗位关系
        ///           5、删除用户部门关系
        ///           6、删除用户
        /// </summary>
        public bool Remove(int userId)
        {
            try
            {
                //档案
                if (this.UserInfoManage.IsExist(p => p.USERID == userId))
                {
                    this.UserInfoManage.Delete(p => p.USERID == userId);
                }
                //用户角色
                if (this.UserRoleManage.IsExist(p => p.FK_USERID == userId))
                {
                    this.UserRoleManage.Delete(p => p.FK_USERID == userId);
                }
                //用户权限
                if (this.UserPermissionManage.IsExist(p => p.FK_USERID == userId))
                {
                    this.UserPermissionManage.Delete(p => p.FK_USERID == userId);
                }
                //用户岗位
                if (this.PostUserManage.IsExist(p => p.FK_USERID == userId))
                {
                    this.PostUserManage.Delete(p => p.FK_USERID == userId);
                }
                //用户部门
                if (this.UserDepartmentManage.IsExist(p => p.USER_ID == userId))
                {
                    this.UserDepartmentManage.Delete(p => p.USER_ID == userId);
                }
                //用户自身
                if (this.IsExist(p => p.ID == userId))
                {
                    this.Delete(p => p.ID == userId);
                }
                return true;
            }
            catch (Exception e) { throw e.InnerException; }
        }

        /// <summary>
        /// 根据用户构造用户基本信息
        /// </summary>
        public Account GetAccountByUser(SYS_USER users)
        {
            if (users == null) return null;
            //用户授权--->注意用户的授权是包括角色权限与自身权限的
            var permission = GetPermissionByUser(users);
            //用户角色
            var role = users.SYS_USER_ROLE.Select(p => p.SYS_ROLE).ToList();
            //用户部门
            var dpt = users.SYS_USER_DEPARTMENT.Select(p => p.SYS_DEPARTMENT).ToList();
            //用户岗位
            var post = users.SYS_POST_USER.ToList();
            //用户主部门
            var dptInfo = this.DepartmentManage.Get(p => p.ID == users.DPTID);
            //用户模块
            var module = permission.Select(p => p.SYS_MODULE).ToList().Distinct(new ModuleDistinct()).ToList();
            Account account = new Account()
            {
                Id = users.ID,
                Name = users.NAME,
                LogName = users.ACCOUNT,
                PassWord = users.PASSWORD,
                IsAdmin = IsAdmin(users.ID),
                DptInfo = dptInfo,
                Dpt = dpt,
                Face_Img = users.FACE_IMG,
                Permissions = permission,
                Roles = role,
                PostUser = post,
                Modules = module
            };
            return account;
        }


        /// <summary>
        /// 从Cookie中获取用户信息
        /// </summary>
        public Account GetAccountByCookie()
        {
            var cookie = Common.CookieHelper.GetCookie("cookie_rememberme");
            if (cookie != null)
            {
                //验证json的有效性
                if (!string.IsNullOrEmpty(cookie.Value))
                {
                    //解密
                    var cookievalue = new Common.CryptHelper.AESCrypt().Decrypt(cookie.Value);
                    //是否为json
                    if (!JsonSplit.IsJson(cookievalue)) return null;
                    try
                    {
                        var jsonFormat = JsonConverter.ConvertJson(cookievalue);
                        if (jsonFormat != null)
                        {
                            var users = UserLogin(jsonFormat.username, new Common.CryptHelper.AESCrypt().Decrypt(jsonFormat.password));
                            if (users != null)
                                return GetAccountByUser(users);
                        }
                    }
                    catch { return null; }
                }
            }
            return null;
        }

        /// <summary>
        /// 根据用户信息获取用户所有的权限
        /// </summary>
        private List<SYS_PERMISSION> GetPermissionByUser(SYS_USER users)
        {
            //1、超级管理员拥有所有权限
            if (IsAdmin(users.ID))
                return PermissionManage.LoadListAll(null);
            //2、普通用户，合并当前用户权限与角色权限
            var perlist = new List<SYS_PERMISSION>();
            //2.1合并用户权限
            perlist.AddRange(users.SYS_USER_PERMISSION.Select(p => p.SYS_PERMISSION).ToList());
            //2.2合同角色权限
            ////todo:经典多对多的数据查询Linq方法
            perlist.AddRange(users.SYS_USER_ROLE.Select(p => p.SYS_ROLE.SYS_ROLE_PERMISSION.Select(c => c.SYS_PERMISSION)).SelectMany(c => c.Select(e => e)).Cast<SYS_PERMISSION>().ToList());
            //3、去重
            ////todo:通过重写IEqualityComparer<T>实现对象去重
            perlist = perlist.Distinct(new PermissionDistinct()).ToList();
            return perlist;
        }

    }

    /// <summary>
    /// 权限去重，非常重要
    /// </summary>
    public class PermissionDistinct : IEqualityComparer<SYS_PERMISSION>
    {
        public bool Equals(SYS_PERMISSION x, SYS_PERMISSION y)
        {
            return x.ID == y.ID;
        }

        public int GetHashCode(SYS_PERMISSION obj)
        {
            return obj.ToString().GetHashCode();
        }
    }
}

五、修改spring配置(Service/Config/Service.xml)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!--系统管理begin-->
<!--用户管理-->
<object id="Service.User" type="Service.ServiceImp.UserManage,Service" singleton="false">
  <property name="UserInfoManage" ref="Service.UserInfo"/>
  <property name="UserRoleManage" ref="Service.UserRole"/>
  <property name="UserPermissionManage" ref="Service.UserPermission"/>
  <property name="PostUserManage" ref="Service.PostUser"/>
  <property name="PermissionManage" ref="Service.Permission"/>
  <property name="DepartmentManage" ref="Service.Department"/>
  <property name="UserDepartmentManage" ref="Service.UserDepartment"/>
</object>

<object id="Service.Module" type="Service.ServiceImp.ModuleManage,Service" singleton="false">
</object>
<object id="Service.UserInfo" type="Service.ServiceImp.UserInfoManage,Service" singleton="false">
</object>
<object id="Service.UserRole" type="Service.ServiceImp.UserRoleManage,Service" singleton="false">
</object>
<object id="Service.PostUser" type="Service.ServiceImp.PostUserManage,Service" singleton="false">
</object>
<object id="Service.UserPermission" type="Service.ServiceImp.UserPermissionManage,Service" singleton="false">
</object>
<object id="Service.Permission" type="Service.ServiceImp.PermissionManage,Service" singleton="false">
</object>
<object id="Service.Department" type="Service.ServiceImp.DepartmentManage,Service" singleton="false">
</object>
<object id="Service.UserDepartment" type="Service.ServiceImp.UserDepartmentManage,Service" singleton="false">
</object>
<!--系统管理end-->
FEATURED TAGS
c#