Esempio n. 1
0
        public async Task <ActionResult> AddMember(string user_uid, int?flag)
        {
            return(await RunActionAsync(async() =>
            {
                if (!ValidateHelper.IsPlumpString(user_uid) || flag == null)
                {
                    return GetJsonRes("参数错误");
                }
                if (!MemberRoleHelper.IsValid(flag.Value))
                {
                    return GetJsonRes("权限值错误");
                }

                var org_uid = this.GetSelectedOrgUID();

                var map = new OrganizationMemberEntity()
                {
                    OrgUID = org_uid,
                    UserUID = user_uid,
                    Flag = flag.Value,
                    MemberApproved = (int)YesOrNoEnum.是,
                    OrgApproved = (int)YesOrNoEnum.是,
                };
                var res = await this._orgService.AddMember(map);
                if (res.error)
                {
                    return GetJsonRes(res.msg);
                }

                return GetJsonRes(string.Empty);
            }));
        }
Esempio n. 2
0
        public async Task <List <UserEntity> > AllMembers(string org_uid)
        {
            return(await this._orgRepo.PrepareSessionAsync(async db =>
            {
                var map_query = db.Set <OrganizationMemberEntity>().AsNoTrackingQueryable();
                var map = map_query.Where(x => x.OrgUID == org_uid);
                var user_uids = map.Select(x => x.UserUID);
                var query = db.Set <UserEntity>().AsNoTrackingQueryable();
                query = query.Where(x => user_uids.Contains(x.UID));

                var list = await query.OrderBy(x => x.IID).Take(1000).ToListAsync();

                if (ValidateHelper.IsPlumpList(list))
                {
                    var uids = list.Select(x => x.UID);
                    var orgs = await map_query.Where(x => uids.Contains(x.UserUID)).ToListAsync();
                    var roles = MemberRoleHelper.GetRoles();
                    foreach (var m in list)
                    {
                        var org = orgs.Where(x => x.UserUID == m.UID).FirstOrDefault();
                        if (org == null)
                        {
                            continue;
                        }

                        m.OrgFlag = org.Flag;
                        m.OrgUID = org.OrgUID;
                        m.OrgFlagName = string.Join(",", MemberRoleHelper.ParseRoleNames(m.OrgFlag, roles).Take(3).ToList());
                    }
                }

                return list;
            }));
        }
Esempio n. 3
0
        public async Task <IActionResult> QueryMemberRoles()
        {
            await Task.CompletedTask;

            var data = MemberRoleHelper.GetRoles();

            return(GetJson(new _()
            {
                Success = true,
                Data = data.Select(x => new { x.Key, x.Value }).ToList()
            }));
        }
Esempio n. 4
0
        public ActionResult QueryMemberRoles()
        {
            return(RunAction(() =>
            {
                var data = MemberRoleHelper.GetRoles();

                return GetJson(new _()
                {
                    success = true,
                    data = data.Select(x => new { x.Key, x.Value }).ToList()
                });
            }));
        }
Esempio n. 5
0
        public async Task <List <UserEntity> > LoadOrgRoles(string org_uid, List <UserEntity> list)
        {
            org_uid.Should().NotBeNullOrEmpty();
            list.Should().NotBeNull();

            if (ValidateHelper.IsNotEmpty(list))
            {
                var db   = this._orgRepo.Database;
                var uids = list.Select(x => x.UID).ToArray();

                var map_query  = db.Set <OrgMemberEntity>().AsNoTrackingQueryable();
                var role_query = db.Set <OrgMemberRoleEntity>().AsNoTrackingQueryable();

                var org_map = await map_query
                              .Where(x => x.OrgUID == org_uid && uids.Contains(x.UserUID))
                              .Select(x => new { x.UserUID, x.IsOwner }).ToArrayAsync();

                var role_map = await role_query
                               .Where(x => x.OrgUID == org_uid && uids.Contains(x.UserUID))
                               .Select(x => new { x.UserUID, x.RoleUID }).ToArrayAsync();


                var roles = MemberRoleHelper.GetRoles();
                foreach (var m in list)
                {
                    var map = org_map.FirstOrDefault(x => x.UserUID == m.UID);
                    if (map != null)
                    {
                        //mapping
                        m.IsOrgOwner = map.IsOwner > 0;
                        //m.OrgFlag = map.Flag;
                        //m.OrgFlagName = string.Join(",", MemberRoleHelper.ParseRoleNames(map.Flag, roles).Take(3).ToList());
                    }
                    //角色
                    m.OrgRoleUIDs = role_map.Where(x => x.UserUID == m.UID).Select(x => x.RoleUID).ToArray();
                }
            }

            return(list);
        }
Esempio n. 6
0
        public async Task <PagerData <UserEntity> > QueryMember(string org_uid, string q, int page, int pagesize)
        {
            return(await this._orgRepo.PrepareSessionAsync(async db =>
            {
                var map_query = db.Set <OrganizationMemberEntity>().AsNoTrackingQueryable();
                var map = map_query.Where(x => x.OrgUID == org_uid);
                var user_uids = map.Select(x => x.UserUID);
                var query = db.Set <UserEntity>().AsNoTrackingQueryable();
                query = query.Where(x => user_uids.Contains(x.UID));

                if (ValidateHelper.IsPlumpString(q))
                {
                    query = query.Where(x => x.UserName == q || x.NickName.StartsWith(q) || x.UserName.StartsWith(q));
                }
                var data = await query.ToPagedListAsync(page, pagesize, x => x.IID);
                if (ValidateHelper.IsPlumpList(data.DataList))
                {
                    var uids = data.DataList.Select(x => x.UID);
                    var orgs = await map_query.Where(x => uids.Contains(x.UserUID)).ToListAsync();
                    var roles = MemberRoleHelper.GetRoles();
                    foreach (var m in data.DataList)
                    {
                        var org = orgs.Where(x => x.UserUID == m.UID).FirstOrDefault();
                        if (org == null)
                        {
                            continue;
                        }

                        m.OrgFlag = org.Flag;
                        m.OrgUID = org.OrgUID;
                        m.OrgFlagName = string.Join(",", MemberRoleHelper.ParseRoleNames(m.OrgFlag, roles));
                    }
                }

                return data;
            }));
        }