feixing/Permission.Service/Services/ChartGroupService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Permission.Entity.Chart;
using Permission.Entity.DbContext;
using Permission.Entity.System;
using Permission.Infrastructure.Repositories;
using Permission.Infrastructure.WebControls;
using Permission.Service.DTO;
using Permission.Service.DTO.ApiModels;
using Permission.Service.IServices;
using Permission.Utils.Validate;

namespace Permission.Service.Services
{
    public class ChartGroupService : IChartGroupService
    {
        private readonly IUnitOfWork _unitOfWork;
        private readonly PermissionContext _dbContext;
        private readonly IMapper _mapper;
        private readonly IBaseRepository<ChartGroup> _chartGroupRepository;
        private readonly IBaseRepository<SysUser> _sysUserRepository;
        private readonly ISysUserService _sysUserService;

        public ChartGroupService(IUnitOfWork unitOfWork, PermissionContext dbContext, IMapper mapper, IBaseRepository<ChartGroup> chartGroupRepository, IBaseRepository<SysUser> sysUserRepository, ISysUserService sysUserService)
        {
            this._unitOfWork = unitOfWork;
            this._dbContext = dbContext;
            this._mapper = mapper;
            this._chartGroupRepository = chartGroupRepository;
            this._sysUserRepository = sysUserRepository;
            this._sysUserService = sysUserService;
        }


        public bool AddModel(ChartGroup model)
        {
            try
            {
                model.GuidId = Guid.NewGuid().ToString();
                model.IsEnabled = model.IsEnabled != null;
                model.DeleteMark = false;
                model.CreateTime = DateTime.Now;
                var res = _chartGroupRepository.Save(model);
                return res;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public bool ModifyModel(ChartGroup model)
        {
            try
            {
                var group = _chartGroupRepository.Get(model.Id);
                group.GroupName = model.GroupName;
                group.SortCode = model.SortCode;
                group.IsEnabled = model.IsEnabled;
                group.ModifyTime = DateTime.Now;
                group.ModifyUser = model.ModifyUser;
                group.Remark = model.Remark;
                var res = _chartGroupRepository.Update(group);
                return res;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public bool DeleteModel(int key)
        {
            bool flag = false;
            try
            {
                if (!key.IsEmpty() || key > 0)
                {
                    var group = _customerById(_dbContext, key);
                    if (group.GroupUsers.Any())
                    {
                        group.GroupUsers.Clear();
                        var model = _chartGroupRepository.Get(key);
                        _chartGroupRepository.Delete(model);
                    }
                    else
                    {
                        var model = _chartGroupRepository.Get(key);
                        _chartGroupRepository.Delete(model);
                    }
                    flag = true;
                }
                else
                {
                    flag = false;
                }
                return flag;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public ChartGroup GetChartGroupByKey(int key)
        {
            try
            {
                if (!key.IsEmpty() || key > 0)
                {
                    var data = _chartGroupRepository.Get(key);
                    return data;
                }
                return null;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public Page<ChartGroup> PageList(string keyword, int pagesize, int pageindex)
        {
            try
            {
                int total = 0;
                if (keyword.IsEmpty())
                {
                    var data = _chartGroupRepository.PageList(pageindex, pagesize, us => us.OrderBy(ur => ur.SortCode),
                        u => u,
                        out total,
                        u => u.DeleteMark == false);

                    return data;
                }
                else
                {
                    var data = _chartGroupRepository.PageList(pageindex, pagesize, us => us.OrderBy(ur => ur.SortCode), u => u,
                        out total,
                        u => u.GroupName.Contains(keyword) && u.DeleteMark == false);
                    return data;
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public List<GroupUsersModel> GetUsersByGroupId(int groupId)
        {
            if (groupId.IsEmpty() || groupId <= 0)
            {
                return null;
            }
            else
            {
                var group = _customerById(_dbContext, groupId);
                var gruopusers = group.GroupUsers;
                var allusers = _sysUserRepository.QueryEntity<SysUser, DateTime, SysUser>(m => m.IsEnabled == true && m.DeleteMark == false, ms => ms.CreateTime.Value, null, true).ToList();
                var data = allusers.Select(u => new GroupUsersModel
                {
                    UserId = u.Id,
                    UserName = u.Account,
                    RealName = u.RealName,
                    IsChecked = gruopusers.Select(us => us.UserId).Contains(u.Id) ? 1 : 0
                }).ToList();
                return data;
            }
        }

        public bool UpdateUsersGroup(int groupId, string userIds)
        {
            bool flag = false;
            if (!groupId.IsEmpty() || groupId > 0)
            {

                List<GroupUser> newUsers = new List<GroupUser>();
                //删除原先旧数据
                try
                {
                    var group = _customerById(_dbContext, groupId);
                    group.GroupUsers.Clear();

                    if (!userIds.IsEmpty())
                    {
                        GroupUser groupUser = null;
                        foreach (var uid in userIds.Split(',').ToList())
                        {
                            groupUser = new GroupUser
                            {
                                UserId = int.Parse(uid),
                                GroupId = groupId,
                                CreateUser = "",
                                CreateTime = DateTime.Now
                            };

                            newUsers.Add(groupUser);
                        }
                        group.GroupUsers.AddRange(newUsers);
                    }
                    bool res = _unitOfWork.SaveChanges() > 0;
                    flag = res;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            else
            {
                flag = false;
            }
            return flag;
        }


        public List<ChartGroup> GetGroupsByUserId(int userId)
        {
            /////
            if (!userId.IsEmpty() || userId > 0)
            {
                var user = _usergroups(_dbContext, userId);
                var groupidlist = user.GroupUsers.Select(m => m.GroupId).ToList();
                var grouplist = _chartGroupRepository.LoadAll(m => groupidlist.Contains(m.Id) && m.IsEnabled == true && m.DeleteMark == false).ToList();
                return grouplist;
            }
            return null;
        }


        public List<SysUser> GetUserByGroupId(int grouoId)
        {
            if (!grouoId.IsEmpty() || grouoId > 0)
            {
                var group = _customerById(_dbContext, grouoId);
                var useridlist = group.GroupUsers.Select(m => m.UserId).ToList();
                var users = _sysUserRepository.LoadAll(m => useridlist.Contains(m.Id) && m.IsEnabled == true && m.DeleteMark == false).ToList();
                return users;
            }
            return null;
        }


        #region 私有方法

        private static Func<PermissionContext, int, ChartGroup> _customerById =
            EF.CompileQuery((PermissionContext db, int groupId) => db.ChartGroups
                          .Include(u => u.GroupUsers)
                          .FirstOrDefault(c => c.Id == groupId));

        private static Func<PermissionContext, int, SysUser> _usergroups =
            EF.CompileQuery((PermissionContext db, int userid) => db.SysUsers
                .Include(u => u.GroupUsers)
                .FirstOrDefault(c => c.Id == userid));

        #endregion

        #region api

        public IEnumerable<GroupModel> GetUserGroupsApi(int userId)
        {
            List<GroupModel> grouplist = new List<GroupModel>();
            List<GroupModel> depgrouplist = new List<GroupModel>();
            int index = 0;
            try
            {
                if (!userId.IsEmpty())
                {
                    var currentUser = _sysUserRepository.Get(userId);
                    int orgId = currentUser.OrganizeId.Value; //获取机构编号

                    GroupModel groupModel = null;
                    if (!orgId.IsEmpty())
                    {
                        var deplist = _sysUserService.GetGroupUsersByOrgIdApi(userId, orgId); //获取机构下部门人员信息
                        if (deplist != null)
                        {
                            if (deplist.Any())
                            {
                                foreach (var dep in deplist)
                                {
                                    groupModel = new GroupModel();
                                    groupModel.GroupId = dep.DepId.ToString();
                                    groupModel.GroupName = dep.DepName;
                                    groupModel.GroupType = 1;
                                    groupModel.OrganizeId = dep.OrgId.ToString();
                                    groupModel.SortCode = index;
                                    groupModel.Status = dep.Status;
                                    groupModel.ManagerId = dep.UserModels[0].UserId.ToString();
                                    groupModel.CreateTime = dep.CreateTime;
                                    groupModel.CreateName = dep.CreateName;
                                    groupModel.Description = dep.Description;
                                    groupModel.UserModels = dep.UserModels;
                                    depgrouplist.Add(groupModel);
                                    index++;
                                }
                            }
                        }
                    }

                    //获取含有当前用户的组
                    var groups = this.GetGroupsByUserId(userId);
                    foreach (var group in groups)
                    {
                        var users = this.GetUserByGroupId(group.Id);
                        var userlist = _mapper.Map<List<UserModel>>(users);

                        groupModel = new GroupModel();
                        groupModel.GroupId = group.Id.ToString();
                        groupModel.GroupName = group.GroupName;
                        groupModel.GroupType = 0;
                        groupModel.OrganizeId = group.OrganizeId;
                        groupModel.SortCode = index;
                        groupModel.Status = group.IsEnabled == true ? 1 : 0;
                        groupModel.ManagerId = userlist[0].UserId.ToString();
                        groupModel.CreateTime = group.CreateTime;
                        groupModel.CreateName = group.CreateUser;
                        groupModel.Description = group.Remark;
                        groupModel.UserModels = userlist;
                        grouplist.Add(groupModel);
                        index++;
                    }

                    if (depgrouplist.Any())
                    {
                        grouplist.AddRange(depgrouplist);
                    }

                    var resdata = grouplist.OrderBy(g => g.SortCode);
                    return resdata;
                }
                else
                {
                    return null;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }


        #endregion
    }
}