DDD领域模型数据访问权限之用户权限（十）

BAS_PRService岗位和角色服务：

  public class BAS_PRService
    {
        //岗位
        private IRepository<BAS_Post> irepositorypost;
        //角色
        private IRepository<BAS_Role> irepositoryrole;
        //岗位和角色
        private IRepository<BAS_PR> irepositorypr;

        BAS_PR bas_pr;

        public BAS_PRService(IRepository<BAS_Post> irepositorypost,
         IRepository<BAS_Role> irepositoryrole,
         IRepository<BAS_PR> irepositorypr)
        {
            this.irepositorypost = irepositorypost;
            this.irepositoryrole = irepositoryrole;
            this.irepositorypr = irepositorypr;

            bas_pr = new BAS_PR(irepositorypr);
        }

        /// <summary>
        /// 将多个岗位添加到角色中
        /// </summary>
        /// <param name="postnames"></param>
        /// <param name="rolename"></param>
        public void CreateBAS_PR(string[] postnames,string rolename)
        {
            var listpost = new List<BAS_Post>();
            for(int i=0;i<postnames.Length;i++)
            {
                var post =
                    irepositorypost.GetByCondition(p => p.Name == postnames[i], p => true)
                    .SingleOrDefault();
                listpost.Add(post);
            }

            var role = irepositoryrole.GetByCondition(p => p.Name == rolename, p => true).SingleOrDefault();
            bas_pr.CreateBAS_PR(listpost, role);
        }

        /// <summary>
        /// 根据岗位名获取PR信息
        /// </summary>
        /// <param name="postname"></param>
        /// <returns></returns>
        public List<BAS_PR> GetPRSByPostName(string postname)
        {
            var post = irepositorypost.GetByCondition(p => p.Name == postname, p => true).
                SingleOrDefault();
            return bas_pr.GetPRSByPost(post);
        }
        /// <summary>
        /// 根据角色名获取PR信息
        /// </summary>
        /// <param name="rolename"></param>
        /// <returns></returns>
        public List<BAS_PR> GetPRSByRoleName(string rolename)
        {
            var role = irepositoryrole.GetByCondition(p => p.Name == rolename, p => true)
                .SingleOrDefault();
            return bas_pr.GetPRSByRole(role);
        }
    }

在基础机构层DDD.Infrastructure添加SessionHelper的帮助类：

public class SessionHelper
    {
        /// <summary>
        /// 添加 Session
        /// </summary>
        /// <param name="strsessionname"></param>
        /// <param name="strvalue"></param>
        public static void AddSession(string strsessionname,string strvalue)
        {
            HttpContext.Current.Session[strsessionname] = strvalue;
            HttpContext.Current.Session.Timeout = 600;
        }
        /// <summary>
        /// 添加多个Session值
        /// </summary>
        /// <param name="strsessioinname"></param>
        /// <param name="strvalues"></param>
        public static void AddSession(string strsessioinname,string[] strvalues)
        {
            HttpContext.Current.Session[strsessioinname] = strvalues;
            HttpContext.Current.Session.Timeout = 600;
        }
           /// <summary>
           /// 得到Session的值
           /// </summary>
           /// <param name="strsessionname"></param>
           /// <returns></returns>
        public static  string[] Gets(string strsessionname)
        {
            if (HttpContext.Current.Session[strsessionname] == null)
                return null;
            return (string[])HttpContext.Current.Session[strsessionname];
        }
    }

在工程DDD.Domain.DomainService中新建：BAS_RoleService服务类：

   public class BAS_RoleService
    {
        //角色
        private IRepository<BAS_Role> irepositoryrole;
        //用户角色
        private IRepository<BAS_User> irepositoryuser;
        //部门
        private IRepository<BAS_Department> irepositorydepartment;
        //岗位
        private IRepository<BAS_Post> irepositorypost;
        //标识容器
        private IRepository<BAS_IdentityContianer> irepositoryidentitycontainer;
        //角色和用户
        private IRepository<BAS_UR> irepositoryur;
        //角色和部门
        private IRepository<BAS_DR> irepositorydr;
        //角色和岗位
        private IRepository<BAS_PR> irepositorypr;

        BAS_Role bas_role;

        //构造函数
        public BAS_RoleService(IRepository<BAS_Role> irepositoryrole,
         IRepository<BAS_User> irepositoryuser,
         IRepository<BAS_Department> irepositorydepartment,
         IRepository<BAS_Post> irepositorypost,
         IRepository<BAS_IdentityContianer> irepositoryidentitycontainer,
         IRepository<BAS_UR> irepositoryur,
         IRepository<BAS_DR> irepositorydr,
         IRepository<BAS_PR> irepositorypr)
        {
            this.irepositoryrole = irepositoryrole;
            this.irepositoryidentitycontainer = irepositoryidentitycontainer;
            this.irepositoryuser = irepositoryuser;
            this.irepositorydepartment = irepositorydepartment;
            this.irepositorypost = irepositorypost;
            this.irepositoryur = irepositoryur;
            this.irepositorydr = irepositorydr;
            this.irepositorypr = irepositorypr;

            bas_role = new BAS_Role(irepositoryrole);
        }

        /// <summary>
        /// 创建角色
        /// </summary>
        /// <param name="name"></param>
        /// <param name="description"></param>
        public void CreateRole(string name,string description)
        {
            var con_id = Guid.NewGuid();
            bas_role.CreateRole(name, description, con_id);

            var bas_identitycontainer = new BAS_IdentityContianer(irepositoryidentitycontainer);
            bas_identitycontainer.CreateIdentityContainer(con_id);
        }

        /// <summary>
        /// 将多个用户添加到角色
        /// </summary>
        /// <param name="usernos"></param>
        /// <param name="rolename"></param>
        public void AddUserToRole(List<string> usernos,string rolename)
        {
            var role = bas_role.GetRoleByName(rolename);
            var users = new List<BAS_User>();
            foreach(var userno in usernos)
            {
                var user = new BAS_User(irepositoryuser).GetUserByNo(userno);
                users.Add(user);
            }
            new BAS_UR(irepositoryur).CreateBAS_UR(users, role);
        }

        /// <summary>
        /// 将多个部门添加到角色
        /// </summary>
        /// <param name="departmentnames"></param>
        /// <param name="rolename"></param>
        public void AddDepartmentToRole(List<string> departmentnames,string rolename)
        {
            var role = bas_role.GetRoleByName(rolename);
            var departments = new List<BAS_Department>();
            foreach(var departmentname in departmentnames)
            {
                var department = new BAS_Department(irepositorydepartment).GetDepartmentByName(departmentname);
                departments.Add(department);
            }

            new BAS_DR(irepositorydr).CreateBAS_DR(departments, role);
        }

        /// <summary>
        /// 将多个岗位添加到角色
        /// </summary>
        /// <param name="postnames"></param>
        /// <param name="rolename"></param>
        public void AddPostToRole(List<string> postnames,string rolename)
        {
            var role = bas_role.GetRoleByName(rolename);
            var posts = new List<BAS_Post>();
            foreach(var postname in postnames)
            {
                var post = new BAS_Post(irepositorypost).GetPostByName(postname);
                posts.Add(post);
            }

            new BAS_PR(irepositorypr).CreateBAS_PR(posts, role);
        }

        /// <summary>
        /// 根据用户NO获取用户所属角色
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public List<BAS_Role> GetRoleByUserNo(string no)
        {
            var urs =
                new BAS_URService(irepositoryuser, irepositoryrole, irepositoryur)
                .GetURSByUserNo(no);
            var roles = new List<BAS_Role>();
            foreach(var ur in urs)
            {
                var role =
                    irepositoryrole.GetByCondition(p => p.Id == ur.BAS_Role.Id, p => true).SingleOrDefault();
                roles.Add(role);
            }
            return roles;
        }
        /// <summary>
        /// 用户是否在一个角色中
        /// </summary>
        /// <param name="no"></param>
        /// <param name="rolename"></param>
        /// <returns></returns>
        public bool IsRoleContainUser(string no,string rolename)
        {
            return GetRoleByUserNo(no).Contains(bas_role.GetRoleByName(rolename));
        }

        /// <summary>
        /// 根据部门名获取所属的角色
        /// </summary>
        /// <param name="departmentname"></param>
        /// <returns></returns>
        public List<BAS_Role > GetRoleByDepartmentName(string departmentname)
        {
            var drs =
                new BAS_DRService(irepositorydepartment, irepositoryrole, irepositorydr)
                .GetDRSByDepartmentName(departmentname);
            var roles = new List<BAS_Role>();
            foreach(var dr in drs)
            {
                var role =
                    irepositoryrole.GetByCondition(p => p.Id == dr.BAS_Role.Id, p => true)
                    .SingleOrDefault();
                roles.Add(role);
            }

            return roles;
        }
        /// <summary>
        /// 某一个部门是否在一个角色中
        /// </summary>
        /// <param name="departmentname"></param>
        /// <param name="rolename"></param>
        /// <returns></returns>
        public bool IsRoleContainDepartment(string departmentname,string rolename)
        {
            return GetRoleByDepartmentName(departmentname).Contains(bas_role.GetRoleByName(rolename));
        }

        /// <summary>
        /// 根据岗位名获取所属角色信息
        /// </summary>
        /// <param name="postname"></param>
        /// <returns></returns>
        public List<BAS_Role> GetRoleByPostName(string postname)
        {
            var prs =
                new BAS_PRService(irepositorypost, irepositoryrole, irepositorypr)
                .GetPRSByPostName(postname);
            var roles = new List<BAS_Role>();
            foreach(var pr in prs)
            {
                var role =
                    irepositoryrole.GetByCondition(p => p.Id == pr.BAS_Role.Id, p => true)
                    .SingleOrDefault();
                roles.Add(role);
            }
            return roles;
        }
        /// <summary>
        /// 判断岗位是否在角色中
        /// </summary>
        /// <param name="postname"></param>
        /// <param name="rolename"></param>
        /// <returns></returns>
        public bool IsRoleContainPost(string postname,string rolename)
        {
            return GetRoleByPostName(postname).Contains(bas_role.GetRoleByName(rolename));
        }
    }

　　创建DomainService服务类：

  public class BAS_UserService
    {
        //用户仓储
        private IRepository<BAS_User> irepositoryuser;
        //标识容器
        private IRepository<BAS_IdentityContianer> irepositoryidentitycontainer;
        //角色
        private IRepository<BAS_Role> irepositoryrole;
        //部门信息
        private IRepository<BAS_Department> irepositorydepartment;
        //岗位信息
        private IRepository<BAS_Post> irepositorypost;
        //用户角色
        private IRepository<BAS_UR> irepositoryur;
        //用户对应的岗位
        private IRepository<BAS_UDPSet> irepositoryudp;
        //部门对应的角色
        private IRepository<BAS_DR> irepositorydr;
        //岗位对应的角色
        private IRepository<BAS_PR> irepositorypr;

        BAS_User bas_user;

        public BAS_UserService(IRepository<BAS_User> irepositoryuser,
        IRepository<BAS_IdentityContianer> irepositoryidentitycontainer,
        IRepository<BAS_Role> irepositoryrole,
        IRepository<BAS_Department> irepositorydepartment,
        IRepository<BAS_Post> irepositorypost,
        IRepository<BAS_UR> irepositoryur,
        IRepository<BAS_UDPSet> irepositoryudp,
        IRepository<BAS_DR> irepositorydr,
        IRepository<BAS_PR> irepositorypr)
        {
            this.irepositoryuser = irepositoryuser;
            this.irepositoryrole = irepositoryrole;
            this.irepositorydepartment = irepositorydepartment;
            this.irepositorypost = irepositorypost;
            this.irepositoryidentitycontainer = irepositoryidentitycontainer;
            this.irepositoryur = irepositoryur;
            this.irepositoryudp = irepositoryudp;
            this.irepositorydr = irepositorydr;
            this.irepositorypr = irepositorypr;

            bas_user = new BAS_User(irepositoryuser);
        }

        /// <summary>
        /// 创建用户
        /// </summary>
        /// <param name="no"></param>
        /// <param name="name"></param>
        /// <param name="mobile"></param>
        /// <param name="password"></param>
        public void CreateUser(string no,string name,string mobile,string password)
        {
            var con_id = Guid.NewGuid();
            bas_user.CreateUser(no, name, mobile, con_id,password);

            var bas_identitycontainer = new BAS_IdentityContianer(irepositoryidentitycontainer);
            bas_identitycontainer.CreateIdentityContainer(con_id);

        }
        /// <summary>
        /// 用户登录
        /// </summary>
        /// <param name="no"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        public bool UserLogin(string no,string password)
        {
            //用户登录验证
            var loginresult = bas_user.LoginVerify(no, password);

            if(loginresult)
            {
                SessionHelper.AddSession("UserNo", no);
                var conids = GetUserAllCon_Id(no);
                var sconids = new string[conids.Count];
                for(int i=0;i<conids.Count;i++)
                {
                    sconids[i] = conids[i].ToString();
                }
                SessionHelper.AddSession("UserConId", sconids);
            }
            return loginresult;
        }
        /// <summary>
        /// 得到用户的所有ID
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        private List<Guid> GetUserAllCon_Id(string no)
        {
            var userallcon_ids = new List<Guid>();
            //获取用户自身的Con_id
            userallcon_ids.Add(bas_user.GetUserByNo(no).Con_Id);

            // 获取用户所属角色的Con_id
            var roleservice = new BAS_RoleService(irepositoryrole, irepositoryuser,
                irepositorydepartment, irepositorypost, irepositoryidentitycontainer, irepositoryur,
                irepositorydr, irepositorypr);
            //获取用户所属的角色
            var userroles = roleservice.GetRoleByUserNo(no);
            userallcon_ids.AddRange(userroles.Select(p => p.Con_Id));
            //获取用户所属的部门
            var departmentservice = new BAS_DepartmentService(irepositorydepartment,
                irepositoryidentitycontainer, irepositoryudp, irepositoryuser);
            var userdepartments = departmentservice.GetDepartmentByUserNo(no);
            userallcon_ids.AddRange(userdepartments.Select(p => p.Con_Id));
            //获取部门所属的角色
            foreach(var userdepartment in userdepartments)
            {
                var roles = roleservice.GetRoleByDepartmentName(userdepartment.Name);
                userallcon_ids.AddRange(roles.Select(p => p.Con_Id));
            }
            //获取用户所属的岗位
            var postservice = new BAS_PostService(irepositorypost, irepositoryidentitycontainer,
                irepositoryuser, irepositoryudp);
            var userposts = postservice.GetPostsByUserNO(no);
            userallcon_ids.AddRange(userposts.Select(p => p.Con_Id));

            foreach (var post in userposts)
            {
                var roles = roleservice.GetRoleByPostName(post.Name);
                userallcon_ids.AddRange(roles.Select(p => p.Con_Id));
            }

            return userallcon_ids;
        }
    }

添加应用层的服务：DDD.Application工程　　（DepartmentAppService）

  public class DepartmentAppService
    {
        IRepositoryContext context = ServiecLocator.Instance.GetService(typeof(IRepositoryContext))
          as IRepositoryContext;
        //部门仓储
        IRepository<BAS_Department> departmentrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_Department>))
            as IRepository<BAS_Department>;
        //标识容器仓储
        IRepository<BAS_IdentityContianer> identitycontainerrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_IdentityContianer>))
    as IRepository<BAS_IdentityContianer>;
        //用户岗位部门仓储
        IRepository<BAS_UDPSet> udprepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_UDPSet>))
as IRepository<BAS_UDPSet>;
        //用户仓储
        IRepository<BAS_User> userrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_User>))
as IRepository<BAS_User>;

        //调用领域服务
        BAS_DepartmentService departmentservice;
        BAS_Department bas_department;

        //构造函数
        public DepartmentAppService()
        {
            departmentservice = new BAS_DepartmentService(departmentrepository,
                identitycontainerrepository, udprepository, userrepository);
            bas_department = new BAS_Department(departmentrepository);
        }

        /// <summary>
        /// 部门创建
        /// </summary>
        /// <param name="name"></param>
        /// <param name="description"></param>
        public void CreateDepartment(string name,string description)
        {
            departmentservice.CreateDepartment(name, description);
            context.Commit();
        }

        /// <summary>
        /// 根据部门名获取部门信息
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public BAS_Department GetDepartmentByName(string name)
        {
            return bas_department.GetDepartmentByName(name);
        }

    }

PostAppService应用层服务：

 public class PostAppService
    {
        IRepositoryContext context = ServiecLocator.Instance.GetService(typeof(IRepositoryContext))
         as IRepositoryContext;
        IRepository<BAS_Post> postrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_Post>))
            as IRepository<BAS_Post>;
        IRepository<BAS_IdentityContianer> identitycontainerrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_IdentityContianer>))
    as IRepository<BAS_IdentityContianer>;
        IRepository<BAS_User> userrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_User>))
as IRepository<BAS_User>;
        IRepository<BAS_UDPSet> udprepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_UDPSet>))
as IRepository<BAS_UDPSet>;

        BAS_PostService postservice;
        BAS_Post bas_post;

        public PostAppService()
        {
            postservice = new BAS_PostService(postrepository, identitycontainerrepository, userrepository,
                udprepository);
            bas_post = new BAS_Post(postrepository);
        }

        /// <summary>
        /// 岗位创建
        /// </summary>
        /// <param name="name"></param>
        /// <param name="description"></param>
        public void CreatePost(string name,string description)
        {
            postservice.CreatePost(name, description);
            context.Commit();
        }
        /// <summary>
        /// 根据岗位名返回岗位对象
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public BAS_Post GetPostByName(string name)
        {
            return bas_post.GetPostByName(name);
        }
    }

添加RoleAppService应用层的服务：

public class RoleAppService
    {
        IRepositoryContext context = ServiecLocator.Instance.GetService(typeof(IRepositoryContext))
          as IRepositoryContext;
        IRepository<BAS_Department> departmentrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_Department>))
            as IRepository<BAS_Department>;
        IRepository<BAS_IdentityContianer> identitycontainerrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_IdentityContianer>))
    as IRepository<BAS_IdentityContianer>;
        IRepository<BAS_Role> rolerepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_Role>))
as IRepository<BAS_Role>;
        IRepository<BAS_User> userrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_User>))
as IRepository<BAS_User>;
        IRepository<BAS_Post> postrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_Post>))
as IRepository<BAS_Post>;
        IRepository<BAS_UR> urrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_UR>))
as IRepository<BAS_UR>;
        IRepository<BAS_DR> drrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_DR>))
as IRepository<BAS_DR>;
        IRepository<BAS_PR> prrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_PR>))
as IRepository<BAS_PR>;

        BAS_RoleService roleserivice;
        BAS_Role bas_role;
        public RoleAppService()
        {
            roleserivice =
                new BAS_RoleService(rolerepository, userrepository, departmentrepository,
                postrepository, identitycontainerrepository, urrepository,
                drrepository, prrepository);
            bas_role = new BAS_Role(rolerepository);
        }

        /// <summary>
        /// 角色创建
        /// </summary>
        /// <param name="name"></param>
        /// <param name="description"></param>
        public void CreateRole(string name,string description)
        {
            roleserivice.CreateRole(name, description);
            context.Commit();
        }
        /// <summary>
        /// 根据角色名返回角色
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public BAS_Role GetRoleByName(string name)
        {
            return bas_role.GetRoleByName(name);
        }

        /// <summary>
        /// 添加用户到角色
        /// </summary>
        /// <param name="usernos"></param>
        /// <param name="rolename"></param>
        public void AddUserToRole(string [] usernos,string rolename)
        {
            roleserivice.AddUserToRole(usernos.ToList(), rolename);
            context.Commit();
        }

        /// <summary>
        /// 添加部门到角色
        /// </summary>
        /// <param name="departmentnames"></param>
        /// <param name="rolename"></param>
        public void AddDepartmentToRole(string [] departmentnames,string rolename)
        {
            roleserivice.AddDepartmentToRole(departmentnames.ToList(), rolename);
            context.Commit();
        }

        /// <summary>
        /// 添加岗位到角色
        /// </summary>
        /// <param name="postnames"></param>
        /// <param name="rolename"></param>
        public void AddPostToRole(string [] postnames,string rolename)
        {
            roleserivice.AddPostToRole(postnames.ToList(), rolename);
            context.Commit();
        }

        /// <summary>
        /// 角色是否包含某个用户
        /// </summary>
        /// <param name="userno"></param>
        /// <param name="rolename"></param>
        /// <returns></returns>
        public bool IsRoleContainUser(string userno,string rolename)
        {
            return roleserivice.IsRoleContainUser(userno, rolename);
        }
        /// <summary>
        /// 角色是否包含某个部门
        /// </summary>
        /// <param name="departmentname"></param>
        /// <param name="rolename"></param>
        /// <returns></returns>
        public bool IsRoleContainDepartment(string departmentname,string rolename)
        {
            return roleserivice.IsRoleContainDepartment(departmentname, rolename);
        }
        /// <summary>
        /// 角色是否包含某个岗位
        /// </summary>
        /// <param name="postname"></param>
        /// <param name="rolename"></param>
        /// <returns></returns>
        public bool IsRoleContainPost(string postname,string rolename)
        {
            return roleserivice.IsRoleContainPost(postname, rolename);
        }
    }

UserAppService应用层的服务：

public class UserAppService
    {
        IRepositoryContext context = ServiecLocator.Instance.GetService(typeof(IRepositoryContext))
          as IRepositoryContext;
        IRepository<BAS_Department> departmentrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_Department>))
            as IRepository<BAS_Department>;
        IRepository<BAS_IdentityContianer> identitycontainerrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_IdentityContianer>))
    as IRepository<BAS_IdentityContianer>;
        IRepository<BAS_Role> rolerepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_Role>))
as IRepository<BAS_Role>;
        IRepository<BAS_User> userrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_User>))
as IRepository<BAS_User>;
        IRepository<BAS_Post> postrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_Post>))
as IRepository<BAS_Post>;
        IRepository<BAS_UR> urrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_UR>))
as IRepository<BAS_UR>;
        IRepository<BAS_DR> drrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_DR>))
as IRepository<BAS_DR>;
        IRepository<BAS_PR> prrepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_PR>))
as IRepository<BAS_PR>;
        IRepository<BAS_UDPSet> udprepository = ServiecLocator.Instance.GetService(typeof(IRepository<BAS_UDPSet>))
as IRepository<BAS_UDPSet>;

        BAS_UserService bas_userservice;
        BAS_User bas_user;
        BAS_UDPService udpservice;

        public UserAppService()
        {
            bas_userservice =
                new BAS_UserService(userrepository, identitycontainerrepository, rolerepository,
                departmentrepository, postrepository, urrepository, udprepository, drrepository, prrepository);
            bas_user = new BAS_User(userrepository);
            udpservice = new BAS_UDPService(udprepository, userrepository, departmentrepository,
                postrepository);
        }

        /// <summary>
        /// 用户创建
        /// </summary>
        /// <param name="no"></param>
        /// <param name="name"></param>
        /// <param name="mobile"></param>
        /// <param name="password"></param>
        public void CreateUser(string no,string name,string mobile,string password)
        {
            bas_userservice.CreateUser(no, name, mobile, password);
            context.Commit();
        }
        /// <summary>
        /// 根据用户NO获取用户对象
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public BAS_User GetUserByNo(string no)
        {
            return bas_user.GetUserByNo(no);
        }
        /// <summary>
        /// 将用户添加到部门与岗位
        /// </summary>
        /// <param name="userno"></param>
        /// <param name="departmentname"></param>
        /// <param name="postname"></param>
        /// <param name="ismain"></param>
        public void CreateDepartmentPostToUser(string userno,string departmentname,string postname
            ,bool ismain)
        {
            udpservice.CreateDepartmentPostToUser(userno, departmentname, postname, ismain);
            context.Commit();
        }
        /// <summary>
        /// 根据部门，用户与岗位信息获取三者连接信息
        /// </summary>
        /// <param name="departmentname"></param>
        /// <param name="userno"></param>
        /// <param name="postname"></param>
        /// <returns></returns>
        public List<BAS_UDPSet> GetUDPByDepartmentUserPost(string departmentname,string userno,
            string postname)
        {
            return udpservice.GetUdpByDepartment(departmentname)
                .Concat(udpservice.GetUdpByPost(postname)).Concat
                (udpservice.GetUdpByUser(userno)).ToList();
        }
    }

如何在T4模板中生成同一个上下文：

添加一下代码：
public partial class SalesOrdersModelContainer : DbContext

添加WebApp连接数据库的配置：

 <connectionStrings>
    <add name="SalesOrdersModelContainer" 
connectionString=
"metadata=res://*/SalesOrdersModel.csdl|res://*/SalesOrdersModel.ssdl|
res://*/SalesOrdersModel.msl|res://*/PermissionModel.csdl|res://*/PermissionModel.ssdl|res://*/PermissionModel.msl;
provider=System.Data.SqlClient;
provider connection string="data source=localhost;initial catalog=SalesOrderDB;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework""
 providerName="System.Data.EntityClient" />
  </connectionStrings>

单元测试代码：

namespace DDD.UnitTest
{
    [TestClass]
    public class PermissionTest
    {
        [TestMethod]
        public void CreateUser()
        {
            UserAppService userappservice =
                new UserAppService();
            userappservice.CreateUser("10", "孙", "1359333", "pass");
            Assert.IsNotNull(userappservice.GetUserByNo("10"));
        }

        [TestMethod]
        public void CreateDepartment()
        {
            DepartmentAppService departmentservice =
                new DepartmentAppService();
            departmentservice.CreateDepartment("财务中心", "进行财务核算与管理");
            Assert.IsNotNull(departmentservice.GetDepartmentByName("财务中心"));
        }

        [TestMethod]
        public void CreatePost()
        {
            PostAppService postservice = new PostAppService();
            postservice.CreatePost("高级会计师", "高级会计师");
            Assert.IsNotNull(postservice.GetPostByName("高级会计师"));
        }

        [TestMethod]
        public void CreateDepartmentPostToUser()
        {
            UserAppService userservice = new UserAppService();
            userservice.CreateDepartmentPostToUser("10", "财务中心", "高级会计师", true);
            Assert.IsNotNull(userservice.GetUDPByDepartmentUserPost("财务中心", "10", "高级会计师"));
        }

        [TestMethod]
        public void CreateRole()
        {
            RoleAppService roleservice =
                new RoleAppService();
            roleservice.CreateRole("角色1", "具有某些权限的角色");
            Assert.IsNotNull(roleservice.GetRoleByName("角色1"));
        }

        [TestMethod]
        public void AddUserToRole()
        {
            RoleAppService roleservice = new RoleAppService();
            string[] usernos = new string[1];
            usernos[0] = "10";
            roleservice.AddUserToRole(usernos, "角色1");
            Assert.IsTrue(roleservice.IsRoleContainUser("10", "角色1"));
        }

        [TestMethod]
        public void AddDepartmentToRole()
        {
            RoleAppService roleservice = new RoleAppService();
            string[] departmentnames = new string[1];
            departmentnames[0] = "财务中心";
            roleservice.AddDepartmentToRole(departmentnames, "角色1");
            Assert.IsTrue(roleservice.IsRoleContainDepartment("财务中心", "角色1"));
        }

        [TestMethod]
        public void AddPostToRole()
        {
            RoleAppService roleservice = new RoleAppService();
            string[] postnames = new string[1];
            postnames[0] = "高级会计师";
            roleservice.AddPostToRole(postnames, "角色1");
            Assert.IsTrue(roleservice.IsRoleContainPost("高级会计师", "角色1"));
        }
    }
}