Docker/CloudBuilder/CloudBuilder.Master.Service/FamilyTreeUtility/FamilyTreePermissionHelper.cs

using CloudBuilder.Core.DatabaseAccessor.Entity;
using CloudBuilder.Master.Entity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CloudBuilder.Master.Service.FamilyTreeUtility
{
    public class FamilyTreePermissionHelper
    {
        private readonly IApplicationService service;

        public FamilyTreePermissionHelper(IApplicationService service)
        {
            this.service = service;
        }

        private FamilyTreeChildrenMapEntity[] childrens = null;
        private FamilyTreeSpouseMapEntity[] spouses = null;

        public bool HasPermission(string treeId, string personId)
        {
            IRepository<FamilyTreePermissionEntity> repositoryPermission = service.GetRepository<IRepository<FamilyTreePermissionEntity>>();
            FamilyTreePermissionEntity[] permissions = repositoryPermission.DetachedEntities.Where(x => x.TreeId == treeId && x.UserName == service.UserId && x.ValidIndc == YesNoPolicy.YES).ToArray();
            if (permissions != null && permissions.Where(x => x.ManagerIndc == YesNoPolicy.YES).Any()) return true;

            return GetPersonId(permissions, treeId).Where(x => x == personId).Any();
        }

        public List<string> GetPersonId(FamilyTreePermissionEntity[] permissions, string treeId)
        {
            List<string> ps = new List<string>();

            if (permissions == null || permissions.Length == 0) return ps;

            IRepository<FamilyTreeChildrenMapEntity> repositoryChildrenMap = service.GetRepository<IRepository<FamilyTreeChildrenMapEntity>>();
            if (childrens == null || childrens.Length == 0)
                childrens = repositoryChildrenMap.DetachedEntities.Where(x => x.TreeId == treeId).ToArray();

            IRepository<FamilyTreeSpouseMapEntity> repositorySpouseMap = service.GetRepository<IRepository<FamilyTreeSpouseMapEntity>>();

            if (childrens == null || childrens.Length == 0)
                spouses = repositorySpouseMap.DetachedEntities.Where(x => x.TreeId == treeId).ToArray();

            foreach (var permission in permissions)
            {
                PackPersonIdByChildrenMaps(childrens, spouses, permission.PersonId, ps);
            }

            return ps;
        }

        public void PackPersonIdByChildrenMaps(FamilyTreeChildrenMapEntity[] childrens, FamilyTreeSpouseMapEntity[] spouses, string personId, List<string> ps)
        {
            if (!ps.Contains(personId))
                ps.Add(personId);

            //所有下级都有权限
            if (childrens != null && childrens.Where(x => x.PersonId == personId).Any())
            {
                foreach (FamilyTreeChildrenMapEntity child in childrens.Where(x => x.PersonId == personId))
                    PackPersonIdByChildrenMaps(childrens, spouses, child.ChildrenId, ps);
            }
            //父亲ID也有权限
            if (childrens != null && childrens.Where(x => x.ChildrenId == personId).Any())
            {
                var p = childrens.Where(x => x.ChildrenId == personId).Select(x => x.PersonId).FirstOrDefault();
                if (!ps.Contains(p))
                    ps.Add(p);
            }
            //配偶都有权限
            PackPersonIdBySpouseMaps(spouses, personId, ps);
        }

        public void PackPersonIdBySpouseMaps(FamilyTreeSpouseMapEntity[] spouses, string personId, List<string> ps)
        {
            if (spouses == null) return;
            if (spouses.Where(x => x.PersonId == personId).Any())
            {
                foreach (FamilyTreeSpouseMapEntity s in spouses.Where(x => x.PersonId == personId))
                {
                    if (!ps.Contains(s.SpouseId))
                        ps.Add(s.SpouseId);
                }
            }
        }
    }
}