using CloudBuilder.Core.DatabaseAccessor.Entity;
using Microsoft.AspNetCore.Authorization;
using CloudBuilder.Core.DatabaseAccessor;
using CloudBuilder.Master.Entity;
using CloudBuilder.Master.Policy;
using CloudBuilder.Master.SearchCriteria;
using CloudBuilder.Master.Data;
using CloudBuilder.Core.Service;
using CloudBuilder.Security.Utility;
using CloudBuilder.Security.Service;
using Microsoft.Extensions.DependencyInjection;
namespace CloudBuilder.Master.Service
{
    public class FamilyGroupService : IFamilyGroupService
    {
        private readonly IApplicationService service;

        private IRepository<FamilyGroupEntity> repository;
        public FamilyGroupService(IApplicationService service)
        {
            this.service = service;
            repository = service.GetRepository<IRepository<FamilyGroupEntity>>();
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Find)]
        public FamilyGroupData FindByKey(string key)
        {
            FamilyGroupData data = new FamilyGroupData();
            FamilyGroupEntity familyGroup = repository.DetachedEntities.Where(x => x.FamilyName == key).FirstOrDefault()!;
            if (familyGroup == null || !YesNoPolicy.IsYes(familyGroup.ValidIndc)) return data;

            data.FamilyGroup = familyGroup;
            data.IsAdd = familyGroup.AddIndc == YesNoPolicy.YES;
            data.IsOpen = familyGroup.OpenIndc == YesNoPolicy.YES;



            IRepository<DmsFolderMapEntity> repositoryDmsFolderMap = repository.GetRepository<IRepository<DmsFolderMapEntity>>();
            DmsFolderMapEntity[] dmsFolderMapss = repositoryDmsFolderMap.DetachedEntities.Where(x => x.FolderNameParent == key).ToArray();

            IRepository<FamilyGroupFolderEntity> repositoryFamilyGroupFolder = repository.GetRepository<IRepository<FamilyGroupFolderEntity>>();

            FamilyGroupFolderEntity[] folders = repositoryFamilyGroupFolder.DetachedEntities.Where(x => x.FamilyName == key).ToArray();

            List<FamilyGroupFolderEntity> lfs = new List<FamilyGroupFolderEntity>();
            foreach (var f in folders)
            {
                foreach (var m in dmsFolderMapss)
                {
                    if (f.FolderName == m.FolderNameSon)
                    {
                        lfs.Add(f);
                        break;
                    }
                }
            }
            folders = lfs.ToArray();

            IRepository<FamilyGroupManagerUserViewEntity> repositoryFamilyGroupManagerUser = repository.GetRepository<IRepository<FamilyGroupManagerUserViewEntity>>();

            FamilyGroupManagerUserViewEntity[] users = repositoryFamilyGroupManagerUser.DetachedEntities.Where(x => x.FamilyName == key).ToArray();

            IRepository<FamilyGroupPermissionUserFolderViewEntity> repositoryFamilyGroupPermissionUserFolder = repository.GetRepository<IRepository<FamilyGroupPermissionUserFolderViewEntity>>();
            FamilyGroupPermissionUserFolderViewEntity[] ufs = repositoryFamilyGroupPermissionUserFolder.DetachedEntities.Where(x => x.FamilyName == key).ToArray();

            if (users == null || users.Length == 0) return data;

            bool isManager = false;
            bool isUser = false;
            IRepository<FamilyGroupManagerEntity> repositoryFamilyGroupManager = repository.GetRepository<IRepository<FamilyGroupManagerEntity>>();
            FamilyGroupManagerEntity[] fgms = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.FamilyName == key && x.ValidIndc == YesNoPolicy.YES).ToArray();
            if (fgms != null && fgms.Length > 0)
            {
                data.FamilyGroupManagers = fgms.Select(x => new FamilyGroupManagerDisplayData(x)
                { UserLocalName = users.Where(y => y.UserName == x.UserName).FirstOrDefault()!.UserLocalName }).ToArray();

                //如果不是管理员,则只能看到有权限的目录

                FamilyGroupManagerEntity[] temp = data.FamilyGroupManagers.Where(x => x.ManagerIndc == YesNoPolicy.YES && x.UserName == service.UserId).ToArray();

                if (temp != null && temp.Length > 0) isManager = true;

                temp = data.FamilyGroupManagers.Where(x => x.ValidIndc == YesNoPolicy.YES && x.UserName == service.UserId).ToArray();
                if (temp != null && temp.Length > 0) isUser = true;
            }

            //如果隐私，不是成员不能查看
            if (familyGroup.OpenIndc == YesNoPolicy.NO && !isUser) return new FamilyGroupData();

            IRepository<FamilyGroupPermissionEntity> repositoryFamilyGroupPermission = repository.GetRepository<IRepository<FamilyGroupPermissionEntity>>();
            FamilyGroupPermissionEntity[] fgps = repositoryFamilyGroupPermission.DetachedEntities.Where(x => x.FamilyName == key).ToArray();

            if (fgps != null && fgps.Length > 0)
            {
                data.FamilyGroupPermissions = fgps.Select(x => new FamilyGroupPermissionDisplayData(x)
                {
                    UserLocalName = users!.Where(y => y.UserName == x.UserName).FirstOrDefault()!.UserLocalName,
                    FolderLocalName = ufs!.Where(y => y.UserName == x.UserName && y.FolderName == x.FolderName).FirstOrDefault()!.FolderLocalName
                }).ToArray();

                if (!isManager)
                {
                    FamilyGroupPermissionDisplayData[] ps = data.FamilyGroupPermissions.Where(x => x.UserName == service.UserId).ToArray();

                    if (ps == null || ps.Length == 0)
                    {
                        data.FamilyGroupFolders = folders!.Select(x => new FamilyGroupFolderDisplayData(x)
                        {
                            IsSharePermission = false,
                        }).ToArray();
                    }
                    else
                    {
                        if (folders != null && folders.Length > 0)
                        {
                            List<FamilyGroupFolderDisplayData> l = new List<FamilyGroupFolderDisplayData>();
                            FamilyGroupFolderDisplayData d;
                            foreach (var item in folders)
                            {
                                d = new FamilyGroupFolderDisplayData(item);
                                if (ps.Where(x => x.FolderName == item.FolderName).Count() > 0)
                                {
                                    d.IsSharePermission = true;
                                }

                                l.Add(d);
                            }

                            data.FamilyGroupFolders = l.ToArray();
                        }

                    }
                    if (!isUser)
                        data.FamilyGroupManagers = null;
                    data.FamilyGroupPermissions = null;
                }

            }


            if (isManager)
            {
                fgms = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.FamilyName == key && x.ValidIndc == YesNoPolicy.NO).ToArray();
                if (fgms != null && fgms.Length > 0)
                    data.FamilyGroupRequests = fgms.Select(x => new FamilyGroupManagerDisplayData(x)
                    { UserLocalName = users!.Where(y => y.UserName == x.UserName).FirstOrDefault()!.UserLocalName }).ToArray();

                //管理员有分享权限
                data.FamilyGroupFolders = folders!.Select(x => new FamilyGroupFolderDisplayData(x)
                {
                    IsSharePermission = true,
                }).ToArray();
            }
            else
            {
                data.FamilyGroupManagers = null;
                fgms = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.FamilyName == key && x.UserName == service.UserId).ToArray();
                if (fgms != null && fgms.Length > 0)
                {
                    data.FamilyGroupManagers = fgms.Where(x => x.ValidIndc == YesNoPolicy.YES)!.Select(x => new FamilyGroupManagerDisplayData(x)
                    { UserLocalName = users!.Where(y => y.UserName == x.UserName).FirstOrDefault()!.UserLocalName }).ToArray();

                    data.FamilyGroupRequests = fgms.Where(x => x.ValidIndc == YesNoPolicy.NO)!.Select(x => new FamilyGroupManagerDisplayData(x)
                    { UserLocalName = users!.Where(y => y.UserName == x.UserName).FirstOrDefault()!.UserLocalName }).ToArray();
                }
            }

            data.IsManager = isManager;

            return data;
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Find)]
        public FamilyGroupResultData FindBySearchCriteria(FamilyGroupSearchCriteria criteria)
        {
            FamilyGroupResultData data = new FamilyGroupResultData();
            FamilyGroupEntity[] list = null;

            Int64 count = 0;

            string sqlWhere = null;

            if (criteria.Filter != null && criteria.Filter.Length > 0)
            {
                sqlWhere = SearchFilter.ComposeWhereClause(criteria.Filter);
            }


            string subIn = $"select {FamilyGroupManagerEntity.DB_FAMILY_NAME} from {FamilyGroupManagerEntity.DB_NAME_FAMILY_GROUP_MANAGER} where {FamilyGroupManagerEntity.DB_USER_NAME}='{service.UserId}'  ";
            sqlWhere = sqlWhere + $" and  {FamilyGroupEntity.DB_VALID_INDC}='Y'  and ( {FamilyGroupEntity.DB_OPEN_INDC}='Y' or ({FamilyGroupEntity.DB_OPEN_INDC}='N' and {FamilyGroupEntity.DB_FAMILY_NAME} in ({subIn})))";


            FamilyGroupEntity entity = FamilyGroupEntity.GetInstance(repository.GetDbContext().Database.ProviderName);
            string sql = entity.GetSelectTopFrom(criteria.limit, criteria.page, criteria.orderby.StringToDbField(), criteria.orderbytag, sqlWhere);

            string err = null;
            try
            {
                list = repository.FromSql(sql).ToArray();
            }
            catch (System.Exception ex)
            {
                err = ex.Message;
            }


            if (list != null && list.Length > 0)
            {
                sql = entity.GetSelectCountFrom(sqlWhere);
                count = Convert.ToInt64(repository.ExecuteScalar(sql));
            }

            data.Limit = criteria.limit;
            data.Page = criteria.page;
            data.Datas = list;
            data.Total = count;
            //data.Sql = sql;
            data.ErrorMessage = err;
            return data;
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Find)]
        public FamilyGroupResultData FindFamilyUserBySearchCriteria(FamilyGroupManagerUserSearchCriteria criteria)
        {
            FamilyGroupResultData data = new FamilyGroupResultData();
            FamilyGroupManagerUserViewEntity[] list = null;

            Int64 count = 0;

            string sqlWhere = null;

            if (criteria.Filter != null && criteria.Filter.Length > 0)
            {
                sqlWhere = SearchFilter.ComposeWhereClause(criteria.Filter);
            }
            string notIn = $"select {FamilyGroupPermissionUserFolderViewEntity.DB_USER_NAME} from {FamilyGroupPermissionUserFolderViewEntity.DB_NAME_FAMILY_GROUP_PERMISSION_USER_FOLDER_VIEW} where {FamilyGroupPermissionUserFolderViewEntity.DB_FAMILY_NAME}='{criteria.FamilyName}' and {FamilyGroupPermissionUserFolderViewEntity.DB_FOLDER_NAME}='{criteria.FolderName}' ";
            sqlWhere = sqlWhere + " and " + FamilyGroupManagerUserViewEntity.DB_USER_NAME + $" not in ({notIn})";
            sqlWhere = sqlWhere + " and " + FamilyGroupManagerUserViewEntity.DB_VALID_INDC + "='Y' ";
            sqlWhere = sqlWhere + $" and {FamilyGroupManagerUserViewEntity.DB_FAMILY_NAME}= '{criteria.FamilyName}' ";

            IRepository<FamilyGroupManagerUserViewEntity> repositoryFamilyGroupManager = repository.GetRepository<IRepository<FamilyGroupManagerUserViewEntity>>();

            FamilyGroupManagerUserViewEntity entity = FamilyGroupManagerUserViewEntity.GetInstance(repository.GetDbContext().Database.ProviderName);
            string sql = entity.GetSelectTopFrom(criteria.limit, criteria.page, criteria.orderby.StringToDbField(), criteria.orderbytag, sqlWhere);

            string err = null;
            try
            {
                list = repositoryFamilyGroupManager.FromSql(sql).ToArray();
            }
            catch (System.Exception ex)
            {
                err = ex.Message;
            }


            if (list != null && list.Length > 0)
            {
                sql = entity.GetSelectCountFrom(sqlWhere);
                count = Convert.ToInt64(repository.ExecuteScalar(sql));
            }

            data.Limit = criteria.limit;
            data.Page = criteria.page;
            data.Users = list;
            data.Total = count;
            //data.Sql = sql;
            data.ErrorMessage = err;
            return data;
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Find)]
        public FamilyGroupResultData FamilyFolderFavoriteBySearchCriteria(FamilyGroupManagerUserSearchCriteria criteria)
        {
            FamilyGroupResultData data = new FamilyGroupResultData();
            FamilyFolderFavoriteViewEntity[] list = null;

            Int64 count = 0;

            string sqlWhere = null;

            if (criteria.Filter != null && criteria.Filter.Length > 0)
            {
                sqlWhere = SearchFilter.ComposeWhereClause(criteria.Filter);
            }

            sqlWhere = sqlWhere + $" and {FamilyFolderFavoriteViewEntity.DB_USER_NAME}='{service.UserId}' ";

            IRepository<FamilyFolderFavoriteViewEntity> repositoryFamilyFolderFavorite = repository.GetRepository<IRepository<FamilyFolderFavoriteViewEntity>>();

            FamilyFolderFavoriteViewEntity entity = FamilyFolderFavoriteViewEntity.GetInstance(repository.GetDbContext().Database.ProviderName);
            string sql = entity.GetSelectTopFrom(criteria.limit, criteria.page, criteria.orderby.StringToDbField(), criteria.orderbytag, sqlWhere);

            string err = null;
            try
            {
                list = repositoryFamilyFolderFavorite.FromSql(sql).ToArray();
            }
            catch (System.Exception ex)
            {
                err = ex.Message;
            }


            if (list != null && list.Length > 0)
            {
                sql = entity.GetSelectCountFrom(sqlWhere);
                count = Convert.ToInt64(repository.ExecuteScalar(sql));
            }

            data.Limit = criteria.limit;
            data.Page = criteria.page;
            data.Favorites = list;
            data.Total = count;
            //data.Sql = sql;
            data.ErrorMessage = err;
            return data;
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Print)]
        public dynamic PrintBySearchCriteria(FamilyGroupSearchCriteria criteria)
        {
            throw new NotImplementedException();
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Insert)]
        [UnitOfWork]
        public FamilyGroupData Insert(FamilyGroupData data)
        {
            FamilyGroupEntity familyGroup = repository.DetachedEntities.Where(x => x.FamilyLocalName == data.FamilyGroup.FamilyLocalName).FirstOrDefault();
            if (familyGroup != null)
            {
                throw new ValidatedException("群组名称已存在.");
            }

            ValidateHelper.Validate(service, data.FamilyGroup, FamilyGroupEntity.DB_NAME_FAMILY_GROUP);

            familyGroup = new FamilyGroupEntity();
            ObjectCopyHelper.Copy(data.FamilyGroup, familyGroup);

            ISecurityGeneratorNumberService securityGeneratorNumberService = service.ServiceProvider.GetService<ISecurityGeneratorNumberService>()!;

            familyGroup.FamilyName = securityGeneratorNumberService.GetNo(MasterPrefixPolicy.FAMILY_GROUP, MasterPrefixPolicy.FAMILY_GROUP_FAMILY_NAME, "FM", YesNoPolicy.NO, "000000");
            familyGroup.ValidIndc = YesNoPolicy.YES;
            familyGroup.ExpireDatetime = null;

            familyGroup.AddIndc = data.IsAdd ? YesNoPolicy.YES : YesNoPolicy.NO;
            familyGroup.OpenIndc = data.IsOpen ? YesNoPolicy.YES : YesNoPolicy.NO;

            repository.InsertNow(familyGroup);

            //创建人是管理员

            FamilyGroupManagerEntity managerEntity = new FamilyGroupManagerEntity();
            managerEntity.FamilyName = familyGroup.FamilyName;
            managerEntity.ValidIndc = YesNoPolicy.YES;
            managerEntity.ManagerIndc = YesNoPolicy.YES;
            managerEntity.UserName = service.UserId;
            managerEntity.Notice = "创建群用户";

            IRepository<FamilyGroupManagerEntity> repositoryFamilyGroupManager = repository.GetRepository<IRepository<FamilyGroupManagerEntity>>();
            repositoryFamilyGroupManager.InsertNow(managerEntity);

            SaveFamilyGroupFolders(familyGroup.FamilyName, data.FamilyGroupFolders);

            //SaveFamilyGroupManagers(familyGroup.FamilyName, data.FamilyGroupManagers);

            //SavePermissions(familyGroup.FamilyName, data.FamilyGroupPermissions);

            //创建群根目录
            IDmsFileService dmsFileService = service.ServiceProvider.GetService<IDmsFileService>()!;
            dmsFileService.CreateFamilyDmsFolder(familyGroup, data.FamilyGroupFolders);

            return FindByKey(familyGroup.FamilyName);
        }

        private void SaveFamilyGroupFolders(string familyName, FamilyGroupFolderEntity[] familyGroupFolders)
        {
            IRepository<FamilyGroupFolderEntity> repositoryFamilyGroupFolder = repository.GetRepository<IRepository<FamilyGroupFolderEntity>>();
            ISecurityGeneratorNumberService securityGeneratorNumberService = service.ServiceProvider.GetService<ISecurityGeneratorNumberService>()!;
            IRepository<DmsFolderMapEntity> repositoryFolderMap = repository.GetRepository<IRepository<DmsFolderMapEntity>>();
            IRepository<DmsFolderEntity> repositoryFolder = repository.GetRepository<IRepository<DmsFolderEntity>>();

            IDmsFileService dmsFileService = service.ServiceProvider.GetService<IDmsFileService>()!;

            FamilyGroupFolderEntity[] olds = repositoryFamilyGroupFolder.Entities.Where(x => x.FamilyName == familyName).ToArray();
            if (olds != null && olds.Length > 0)
            {
                //存在更新，不存在删除
                foreach (FamilyGroupFolderEntity old in olds)
                {
                    if (familyGroupFolders != null && familyGroupFolders.Length > 0 && familyGroupFolders.Where(x => x.FolderId == old.FolderId).Count() > 0)
                    {
                        FamilyGroupFolderEntity folder = familyGroupFolders.Where(x => x.FolderId == old.FolderId).FirstOrDefault();
                        old.FolderLocalName = folder.FolderLocalName;
                        old.Notice = folder.Notice;
                        repositoryFamilyGroupFolder.UpdateNow(old);
                    }
                    else
                    {
                        repositoryFamilyGroupFolder.DeleteNow(old);

                        //删除主目录所有内容
                        DmsFolderEntity folder = repositoryFolder.DetachedEntities.Where(x => x.FolderName == old.FolderName).FirstOrDefault()!;
                        if (folder != null)
                        {
                            dmsFileService.DeleteFolder(folder.FolderName);
                        }


                        //删除目录的时候，也要删除目录对应的权限
                        IRepository<FamilyGroupPermissionEntity> repositoryFamilyGroupPermission = repository.GetRepository<IRepository<FamilyGroupPermissionEntity>>();
                        FamilyGroupPermissionEntity[] permissions = repositoryFamilyGroupPermission.DetachedEntities.Where(x => x.FamilyName == old.FamilyName && x.FolderName == old.FolderName).ToArray();
                        if (permissions != null && permissions.Length > 0)
                        {
                            foreach (var item in permissions)
                            {
                                repositoryFamilyGroupPermission.DeleteNow(item);
                            }
                        }
                    }
                }
            }

            if (familyGroupFolders == null || familyGroupFolders.Length == 0) return;

            List<FamilyGroupPermissionEntity> manages = new List<FamilyGroupPermissionEntity>();
            FamilyGroupPermissionEntity familyGroupPermission;
            foreach (FamilyGroupFolderEntity dto in familyGroupFolders)
            {
                //原来不存在的插入
                if (!string.IsNullOrEmpty(dto.CreatedBy)) continue;

                ValidateHelper.Validate(service, dto, FamilyGroupFolderEntity.DB_NAME_FAMILY_GROUP_FOLDER);

                FamilyGroupFolderEntity familyGroupFolderEntity = new FamilyGroupFolderEntity()
                {
                    FolderName = securityGeneratorNumberService.GetNo(MasterPrefixPolicy.DMS_FOLDER, MasterPrefixPolicy.DMS_FOLDER_FOLDER_NAME, "FG", YesNoPolicy.NO, "00000000"),
                    FamilyName = familyName,
                    FolderLocalName = dto.FolderLocalName,
                    Notice = dto.Notice,
                };
                //顶级目录
                familyGroupFolderEntity.TopFolderName = familyGroupFolderEntity.FolderName;

                repositoryFamilyGroupFolder.InsertNow(familyGroupFolderEntity);

                dto.FolderName = familyGroupFolderEntity.FolderName;

                
                familyGroupPermission = new FamilyGroupPermissionEntity();
                familyGroupPermission.FamilyName = familyName;
                familyGroupPermission.FolderName = dto.FolderName;
                familyGroupPermission.UserName = service.UserId;
                manages.Add(familyGroupPermission);
            }
            InsertFamilyGroupPermission(manages.ToArray());

        }

        private void SavePermissions(string familyName, FamilyGroupPermissionEntity[] permissions)
        {
            IRepository<FamilyGroupPermissionEntity> repositoryFamilyGroupPermission = repository.GetRepository<IRepository<FamilyGroupPermissionEntity>>();

            FamilyGroupPermissionEntity[] olds = repositoryFamilyGroupPermission.Entities.Where(x => x.FamilyName == familyName).ToArray();
            if (olds != null && olds.Length > 0)
            {
                //存在更新，不存在删除
                foreach (FamilyGroupPermissionEntity old in olds)
                {
                    if (permissions != null && permissions.Length > 0 && permissions.Where(x => x.UserName == old.UserName && x.FolderName == old.FolderName).Count() > 0)
                    {
                        FamilyGroupPermissionEntity folder = permissions.Where(x => x.UserName == old.UserName && x.FolderName == old.FolderName).FirstOrDefault();
                        old.DeleteIndc = folder.DeleteIndc;
                        old.CreateIndc = folder.CreateIndc;
                        repositoryFamilyGroupPermission.UpdateNow(old);
                    }
                    else
                    {
                        repositoryFamilyGroupPermission.DeleteNow(old);
                    }
                }
            }

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

            foreach (FamilyGroupPermissionEntity dto in permissions)
            {
                //原来不存在的插入
                if (!string.IsNullOrEmpty(dto.CreatedBy)) continue;

                ValidateHelper.Validate(service, dto, FamilyGroupPermissionEntity.DB_NAME_FAMILY_GROUP_PERMISSION);

                repositoryFamilyGroupPermission.InsertNow(new FamilyGroupPermissionEntity()
                {
                    FamilyName = familyName,
                    UserName = dto.UserName,
                    FolderName = dto.FolderName,
                    CreateIndc = YesNoPolicy.YES,
                    DeleteIndc = YesNoPolicy.YES,
                });
            }

        }

        private void SaveFamilyGroupManagers(string familyName, FamilyGroupManagerDisplayData[] managers)
        {
            IRepository<FamilyGroupManagerEntity> repositoryFamilyGroupManager = repository.GetRepository<IRepository<FamilyGroupManagerEntity>>();

            FamilyGroupManagerEntity[] olds = repositoryFamilyGroupManager.Entities.Where(x => x.FamilyName == familyName).ToArray();
            if (olds != null && olds.Length > 0)
            {
                //存在更新，不存在删除
                foreach (FamilyGroupManagerEntity old in olds)
                {
                    if (managers != null && managers.Length > 0 && managers.Where(x => x.UserName == old.UserName).Count() > 0)
                    {
                        FamilyGroupManagerDisplayData mg = managers.Where(x => x.UserName == old.UserName).FirstOrDefault();

                        old.ManagerIndc = mg.IsManager ? YesNoPolicy.YES : YesNoPolicy.NO;
                        repositoryFamilyGroupManager.UpdateNow(old);
                    }
                    else
                    {
                        if (old.ValidIndc != YesNoPolicy.YES) continue;
                        repositoryFamilyGroupManager.DeleteNow(old);

                        //删除成员的时候，也要删除成员对应的权限
                        IRepository<FamilyGroupPermissionEntity> repositoryFamilyGroupPermission = repository.GetRepository<IRepository<FamilyGroupPermissionEntity>>();
                        FamilyGroupPermissionEntity[] permissions = repositoryFamilyGroupPermission.DetachedEntities.Where(x => x.FamilyName == old.FamilyName && x.UserName == old.UserName).ToArray();
                        if (permissions != null && permissions.Length > 0)
                        {
                            foreach (var item in permissions)
                            {
                                repositoryFamilyGroupPermission.DeleteNow(item);
                            }
                        }
                    }
                }
            }
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Update)]
        [UnitOfWork]
        public FamilyGroupData Update(FamilyGroupData data)
        {
            FamilyGroupEntity familyGroup = repository.DetachedEntities.Where(x => x.FamilyName == data.FamilyGroup.FamilyName).FirstOrDefault();
            if (familyGroup == null)
            {
                throw new ValidatedException("记录不存在.");
            }

            familyGroup = repository.DetachedEntities.Where(x => x.FamilyName != data.FamilyGroup.FamilyName && x.FamilyLocalName == data.FamilyGroup.FamilyLocalName).FirstOrDefault();
            if (familyGroup != null)
            {
                throw new ValidatedException("群组名称已存在.");
            }

            ValidateHelper.Validate(service, data.FamilyGroup, FamilyGroupEntity.DB_NAME_FAMILY_GROUP);

            familyGroup = new FamilyGroupEntity();
            ObjectCopyHelper.Copy(data.FamilyGroup, familyGroup);

            ISecurityGeneratorNumberService securityGeneratorNumberService = service.ServiceProvider.GetService<ISecurityGeneratorNumberService>()!;

            familyGroup.AddIndc = data.IsAdd ? YesNoPolicy.YES : YesNoPolicy.NO;
            familyGroup.OpenIndc = data.IsOpen ? YesNoPolicy.YES : YesNoPolicy.NO;

            repository.UpdateNow(familyGroup);

            //因为SavePermissions要在SaveFamilyGroupFolders之前，因为SaveFamilyGroupFolders要插入管理员的权限
            SavePermissions(familyGroup.FamilyName, data.FamilyGroupPermissions);
            SaveFamilyGroupFolders(familyGroup.FamilyName, data.FamilyGroupFolders);
            SaveFamilyGroupManagers(familyGroup.FamilyName, data.FamilyGroupManagers);

            //创建群根目录
            IDmsFileService dmsFileService = service.ServiceProvider.GetService<IDmsFileService>()!;
            dmsFileService.CreateFamilyDmsFolder(familyGroup, data.FamilyGroupFolders);

            return FindByKey(familyGroup.FamilyName);
        }


        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Delete)]
        [UnitOfWork]
        public void Delete(string key)
        {
            FamilyGroupEntity familyGroup = repository.DetachedEntities.Where(x => x.FamilyName == key).FirstOrDefault();
            if (familyGroup == null)
            {
                throw new ValidatedException("记录不存在.");
            }
            bool isManager = false;

            IRepository<FamilyGroupManagerEntity> repositoryFamilyGroupManager = repository.GetRepository<IRepository<FamilyGroupManagerEntity>>();
            FamilyGroupManagerEntity[] fgms = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.ManagerIndc == YesNoPolicy.YES && x.UserName == service.UserId && x.FamilyName == key && x.ValidIndc == YesNoPolicy.YES).ToArray();
            if (fgms == null || fgms.Length == 0)
            {
                throw new ValidatedException("您不是管理员,不能解散");
            }

            familyGroup.ValidIndc = YesNoPolicy.NO;

            repository.UpdateNow(familyGroup);

        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Update)]
        [UnitOfWork]
        public void InsertFamilyGroupManager(FamilyGroupManagerEntity manager)
        {
            IRepository<FamilyGroupManagerEntity> repositoryFamilyGroupManager = repository.GetRepository<IRepository<FamilyGroupManagerEntity>>();
            FamilyGroupManagerEntity org = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.FamilyName == manager.FamilyName && x.UserName == service.UserId).FirstOrDefault()!;
            if (org != null) { throw new ValidatedException("您已申请加入,耐心等待审核。"); }

            org = new FamilyGroupManagerEntity();
            org.FamilyName = manager.FamilyName;
            org.UserName = service.UserId;
            org.ManagerIndc = YesNoPolicy.NO;
            org.ValidIndc = YesNoPolicy.NO;
            org.Notice = manager.Notice;

            repositoryFamilyGroupManager.InsertNow(org);
        }


        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Insert)]
        [UnitOfWork]
        public void InsertFamilyGroupPermission(FamilyGroupPermissionEntity[] managers)
        {
            IRepository<FamilyGroupPermissionEntity> repositoryFamilyGroupPermission = repository.GetRepository<IRepository<FamilyGroupPermissionEntity>>();

            if (managers != null && managers.Length > 0)
            {
                foreach (FamilyGroupPermissionEntity manager in managers)
                {
                    manager.DeleteIndc = YesNoPolicy.YES;
                    manager.CreateIndc = YesNoPolicy.YES;
                    repositoryFamilyGroupPermission.InsertNow(manager);
                }
            }
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Update)]
        [UnitOfWork]
        public void UpdateFamilyGroupManager(FamilyGroupManagerEntity manager)
        {
            IRepository<FamilyGroupManagerEntity> repositoryFamilyGroupManager = repository.GetRepository<IRepository<FamilyGroupManagerEntity>>();

            FamilyGroupManagerEntity[] fgms = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.ManagerIndc == YesNoPolicy.YES && x.UserName == service.UserId && x.FamilyName == manager.FamilyName && x.ValidIndc == YesNoPolicy.YES).ToArray();
            if (fgms == null || fgms.Length == 0)
            {
                throw new ValidatedException("您不是管理员");
            }

            FamilyGroupManagerEntity org = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.FamilyName == manager.FamilyName && x.UserName == manager.UserName).FirstOrDefault()!;
            if (org == null) { return; }

            org.ValidIndc = manager.ValidIndc;

            repositoryFamilyGroupManager.UpdateNow(org);
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Update)]
        [UnitOfWork]
        public void DeleteFamilyGroupManager(FamilyGroupManagerEntity manager)
        {
            IRepository<FamilyGroupManagerEntity> repositoryFamilyGroupManager = repository.GetRepository<IRepository<FamilyGroupManagerEntity>>();

            FamilyGroupManagerEntity[] fgms = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.ManagerIndc == YesNoPolicy.YES && x.UserName == service.UserId && x.FamilyName == manager.FamilyName && x.ValidIndc == YesNoPolicy.YES).ToArray();
            if (fgms == null || fgms.Length == 0)
            {
                throw new ValidatedException("您不是管理员");
            }

            FamilyGroupManagerEntity org = repositoryFamilyGroupManager.DetachedEntities.Where(x => x.FamilyName == manager.FamilyName && x.UserName == manager.UserName).FirstOrDefault()!;
            if (org == null) { return; }

            repositoryFamilyGroupManager.DeleteNow(org);
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Insert)]
        public void InsertFamilyFolderFavorite(string folderName)
        {
            IRepository<FamilyFolderFavoriteEntity> repositoryFamilyFolderFavorite = repository.GetRepository<IRepository<FamilyFolderFavoriteEntity>>();
            FamilyFolderFavoriteEntity folderFavorite = new FamilyFolderFavoriteEntity();
            folderFavorite.FolderName = folderName;
            folderFavorite.UserName = service.UserId;
            repositoryFamilyFolderFavorite.InsertNow(folderFavorite);
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Update)]
        public void DeleteFamilyFolderFavorite(string folderName)
        {
            IRepository<FamilyFolderFavoriteEntity> repositoryFamilyFolderFavorite = repository.GetRepository<IRepository<FamilyFolderFavoriteEntity>>();
            FamilyFolderFavoriteEntity folderFavorite = new FamilyFolderFavoriteEntity();
            folderFavorite.FolderName = folderName;
            folderFavorite.UserName = service.UserId;
            repositoryFamilyFolderFavorite.DeleteNow(folderFavorite);
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyGroup, operate: Operate.Update)]
        public void DeleteFamilyFolderFavorites(FamilyFolderFavoriteEntity[] familyFolderFavorites)
        {
            if (familyFolderFavorites == null || familyFolderFavorites.Length == 0) return;

            IRepository<FamilyFolderFavoriteEntity> repositoryFamilyFolderFavorite = repository.GetRepository<IRepository<FamilyFolderFavoriteEntity>>();
            foreach (var item in familyFolderFavorites)
            {
                repositoryFamilyFolderFavorite.DeleteNow(item);
            }

        }

    }
}