TEAMModelOS/TEAMModelAPI/Controllers/School/GroupListController.cs

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using System.Text.Json;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Extension;
using Azure.Cosmos;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;
using System.IO;
using System.Dynamic;
using System.Net.Http;
using System.Net;
using Newtonsoft.Json;
using System.Linq;
using StackExchange.Redis;
using static TEAMModelOS.SDK.Models.Teacher;
using Microsoft.Extensions.Configuration;
using TEAMModelOS.Filter;
using Microsoft.AspNetCore.Authorization;
using HTEXLib.COMM.Helpers;
using TEAMModelOS.SDK.Models.Service;
namespace TEAMModelAPI.Controllers
{
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ApiController]
    [Route("school")]
    public class GroupListController : ControllerBase
    {
        public AzureCosmosFactory _azureCosmos;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly IConfiguration _configuration;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        private readonly AzureServiceBusFactory _serviceBus;
        public GroupListController(CoreAPIHttpService coreAPIHttpService, AzureCosmosFactory azureCosmos, AzureStorageFactory azureStorage, AzureRedisFactory azureRedis, DingDing dingDing, IOptionsSnapshot<Option> option, IConfiguration configuration, AzureServiceBusFactory serviceBus)
        {
            _azureCosmos = azureCosmos;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
            _dingDing = dingDing;
            _option = option?.Value;
            _configuration = configuration;
            _coreAPIHttpService = coreAPIHttpService;
            _serviceBus = serviceBus;
        }

        /*
            "periodId":"学段（选填）"
         */
        /// <summary>
        ///  获取学校的行政班，教学班，教研组，研修名单
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-group-list")]
        [ApiToken(Auth = "1201", Name = "学校名单列表", RW = "R", Limit = false)]
        public async Task<IActionResult> GetGroupList(JsonElement json)
        {
            var client = _azureCosmos.GetCosmosClient();
            var (id, school) = HttpContext.GetApiTokenInfo();
            json.TryGetProperty("periodId", out JsonElement periodId);
            List<GroupListGrp> groupLists = new List<GroupListGrp>();
            //包含，学校的行政班，教学班
            json.TryGetProperty("type", out JsonElement _type);
            List<string> types = null;
            if (_type.ValueKind.Equals(JsonValueKind.Array))
            {
                types = _type.ToObject<List<string>>();
            }
            else if (_type.ValueKind.Equals(JsonValueKind.String))
            {
                types = new List<string> { $"{types}" };
            }
            if (types.IsEmpty() || types.Contains("class"))
            {
                StringBuilder classsql = new StringBuilder($"SELECT c.id,c.name,c.periodId ,c.year  FROM c ");
                if (!string.IsNullOrEmpty($"{periodId}"))
                {
                    classsql.Append($" where  c.periodId='{periodId}' ");
                }
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<ClassInfo>(queryText: classsql.ToString(),
                    requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Class-{school}") }))
                {
                    HashSet<string> groupNames = new HashSet<string>();
                    string gpsql = $"SELECT distinct c.groupId,c.groupName FROM c where  c.classId='{item.id}'and c.groupName <>null";
                    await foreach (var gp in client.GetContainer(Constant.TEAMModelOS, "Student").GetItemQueryIterator<Student>(queryText: gpsql,
                        requestOptions: new QueryRequestOptions() { PartitionKey = new Azure.Cosmos.PartitionKey($"Base-{school}") }))
                    {
                        groupNames.Add(gp.groupName);
                    }
                    ///行政班（学生搜寻classId动态返回）class
                    GroupListGrp group = new GroupListGrp
                    {
                        id = item.id,
                        code = $"GroupList-{school}",
                        name = item.name,
                        periodId = item.periodId,
                        scope = "school",
                        school = $"{school}",
                        type = "class",
                        year = item.year,
                        groupName = groupNames
                    };
                    groupLists.Add(group);
                }
            }
            if (types.IsEmpty() || types.Contains("teach"))
            {
                //教学班
                StringBuilder teachsql = new StringBuilder($" SELECT distinct value(c) FROM c  where c.type='teach'");
                if (!string.IsNullOrEmpty($"{periodId}"))
                {
                    teachsql.Append($" and c.periodId='{periodId}'");
                }
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                    GetItemQueryIterator<GroupList>(queryText: teachsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                {
                    HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                    groupLists.Add(new GroupListGrp(item, groupName));
                }
            }
            if (types.IsEmpty() || types.Contains("research"))
            {
                //教研组
                StringBuilder researchsql = new StringBuilder($"SELECT distinct value(c) FROM c   where c.type='research'");
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                    GetItemQueryIterator<GroupList>(queryText: researchsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                {
                    HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                    groupLists.Add(new GroupListGrp(item, groupName));
                }
            }

            if (types.IsEmpty() || types.Contains("yxtrain"))
            {
                //研修名单
                StringBuilder yxtrainsql = new StringBuilder($"SELECT distinct value(c) FROM c    where c.type='yxtrain'");
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                    GetItemQueryIterator<GroupList>(queryText: yxtrainsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                {
                    HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                    groupLists.Add(new GroupListGrp(item, groupName));
                }
            }
            return Ok(new
            {
                groupLists = groupLists.Select(x => new { x.id, x.type, x.name, x.periodId, x.school, x.scope, x.year })
            });
        }
        [ProducesDefaultResponseType]
        [HttpPost("get-group-members")]
        [ApiToken(Auth = "1202", Name = "获取名单详细信息和成员信息", RW = "R", Limit = false)]
        public async Task<IActionResult> GetGroupMembers(JsonElement json)
        {
            var client = _azureCosmos.GetCosmosClient();
            if (!json.TryGetProperty("ids", out JsonElement ids)) return BadRequest();
            var (id, school) = HttpContext.GetApiTokenInfo();
            List<string> listids = ids.ToObject<List<string>>();
            (List<RMember> members, List<RGroupList> groups) = await GroupListService.GetStutmdidListids(_coreAPIHttpService, client, _dingDing, listids, $"{school}");
            return Ok(new { groups = groups.Select(x => new { x.name, x.no, x.periodId, x.school, x.type, x.year, x.tcount, x.scount, x.leader, x.members, x.id }), members });
        }
        /// <summary>
        /// 导入行政班学生
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("import-class-members")]
        [ApiToken(Auth = "1203", Name = "导入行政班学生", RW = "W", Limit = false)]
        public async Task<IActionResult> ImportClassMembers(JsonElement json)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            if (!json.TryGetProperty("periodId", out JsonElement _periodId)) { return Ok(new { error = 2, msg = "学段信息错误！" }); }
            if (json.TryGetProperty("students", out JsonElement _students)) { return Ok(new { error = 1, msg = "学生列表格式错误！" }); } 
            if (_students.ValueKind.Equals(JsonValueKind.Array))
            {
                School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                Period period = data.period.Find(x => x.id.Equals($"{_periodId}"));
                if (period != null)
                {
                    List<Student> webStudents = _students.ToObject<List<Student>>();
                    List<Student> preStudents = await StudentService.GeStudentData(_azureCosmos, school, webStudents?.Select(x=>x.id));
                    var retUpsert = await StudentService.upsertStudents(_azureCosmos, _dingDing, _option, school, json.GetProperty("students").EnumerateArray());
                    await StudentService.CheckStudent(_serviceBus, _configuration, _azureCosmos, school, webStudents, preStudents);
                    return this.Ok(new { code = $"{school}", students = retUpsert.studs, retUpsert.classDuplNos, retUpsert.errorIds });
                }
                else 
                {
                    return Ok(new { error = 2, msg = "学段信息错误！" }); 
                }
            }
            else {
                return Ok(new { error = 1, msg = "学生列表格式错误" });
            }
        }
        /// <summary>
        ///更新學生資料，批量密碼重置，基本資訊更新(姓名、教室ID、性別、學年及座號)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("update-class-members")]
        [ApiToken(Auth = "1204", Name = "更新行政班学生", RW = "W", Limit = false)]
        public async Task<IActionResult> UpdateClassMembers(JsonElement json)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            if (!json.TryGetProperty("periodId", out JsonElement _periodId)) { return Ok(new { error = 2, msg = "学段信息错误！" }); }
            if (json.TryGetProperty("students", out JsonElement _students)) { return Ok(new { error = 1, msg = "学生列表格式错误！" }); }
            if (_students.ValueKind.Equals(JsonValueKind.Array))
            {
                School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                Period period = data.period.Find(x => x.id.Equals($"{_periodId}"));
                if (period != null)
                {
                    //更新學生資料，批量密碼重置，基本資訊更新(姓名、教室ID、性別、學年及座號)
                    List<Student> webStudents = json.GetProperty("students").ToObject<List<Student>>();
                    List<Student> preStudents = await StudentService.GeStudentData(_azureCosmos, school, webStudents?.Select(x => x.id));
                    var retUpdate = await StudentService.updateStudents(_azureCosmos, _dingDing, _option, school, json.GetProperty("students").EnumerateArray());
                    await StudentService.CheckStudent(_serviceBus, _configuration, _azureCosmos, school, webStudents, preStudents);
                    return this.Ok(new { code = school, students = retUpdate.studs, retUpdate.classDuplNos, retUpdate.nonexistentIds, retUpdate.errorNos, retUpdate.errorClassId });
                }
                else
                {
                    return Ok(new { error = 2, msg = "学段信息错误！" });
                }
            }
            else
            {
                return Ok(new { error = 1, msg = "学生列表格式错误" });
            }
        }
        /// <summary>
        ////將學生基本資料內的classId、no、groupId及groupName寫入null
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("remove-class-members")]
        [ApiToken(Auth = "1205", Name = "移除行政班学生", RW = "W", Limit = false)]
        public async Task<IActionResult> RemoveClassMembers(JsonElement json)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            if (!json.TryGetProperty("periodId", out JsonElement _periodId)) { return Ok(new { error = 2, msg = "学段信息错误！" }); }
            if (json.TryGetProperty("students", out JsonElement _students)) { return Ok(new { error = 1, msg = "学生列表格式错误！" }); }
            if (_students.ValueKind.Equals(JsonValueKind.Array))
            {
                School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                Period period = data.period.Find(x => x.id.Equals($"{_periodId}"));
                if (period != null)
                {
                    //將學生基本資料內的classId、no、groupId及groupName寫入null
                    List<string> stus = json.GetProperty("students").ToObject<List<string>>();
                    List<Student> webStudents = new List<Student>();
                    foreach (string idstu in stus)
                    {
                        webStudents.Add(new Student { id = idstu, code = $"Base-{school}" });
                    }
                    List<Student>  preStudents = await StudentService.GeStudentData(_azureCosmos, school, webStudents?.Select(x => x.id));
                    (List<string> studs, List<string> nonexistentIds, List<string> errorIds) retRemove = await StudentService.removeStudentClassInfo(    _azureCosmos, _dingDing, _option,school, json.GetProperty("students").EnumerateArray());
                    await StudentService.CheckStudent(_serviceBus, _configuration, _azureCosmos, school, webStudents, preStudents);
                    return Ok(new { code = $"{school}", ids = retRemove.studs, retRemove.nonexistentIds, retRemove.errorIds });
                }
                else
                {
                    return Ok(new { error = 2, msg = "学段信息错误！" });
                }
            }
            else
            {
                return Ok(new { error = 1, msg = "学生列表格式错误" });
            }
        }

        /// <summary>
        /// 创建或更新教学班基本信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("upsert-teach-groups")]
        [ApiToken(Auth = "1206", Name = "创建或更新教学班", RW = "W", Limit = false)]
        public async Task<IActionResult> UpsertTeachGroups(JsonElement json) {
            var (_, school) = HttpContext.GetApiTokenInfo();
            if (!json.TryGetProperty("groupLists", out JsonElement _groupLists)  || !_groupLists.ValueKind.Equals(JsonValueKind.Array)) { return Ok(new { error=1,msg="名单对象不存在"}); }
            var groupListsDto = _groupLists.ToObject<List<GroupListDto>>();
            List<GroupList> groupLists = new List<GroupList>(); ;
            List<Dictionary<string, string>> errorData = new List<Dictionary<string, string>>();
            if (groupListsDto != null && groupListsDto.Valid().isVaild)
            {
                School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                foreach (var list in groupListsDto) {
                    Period period = data.period.Find(x => x.id.Equals($"{list.periodId}"));
                    if (period != null)
                    {
                        GroupList groupList = null;
                        if (string.IsNullOrWhiteSpace(list.id))
                        {
                            groupList = new GroupList()
                            {
                                pk = "GroupList",
                                id = Guid.NewGuid().ToString(),
                                code = $"GroupList-{school}",
                                name = list.name,
                                periodId = list.periodId,
                                scope = "school",
                                school = school,
                                type = "teach",
                                year = list.year,
                                froms = 3
                            };
                            groupList = await GroupListService.CheckListNo(groupList, _azureCosmos, _dingDing, _option);
                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).CreateItemAsync(groupList, new PartitionKey(groupList.code));
                        }
                        else
                        {
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{list.id}", new PartitionKey($"GroupList-{school}"));
                            if (response.Status == 200)
                            {
                                JsonDocument jsonDocument = JsonDocument.Parse(response.Content);
                                groupList = jsonDocument.RootElement.ToObject<GroupList>();
                                groupList.name = string.IsNullOrWhiteSpace(list.name) ? groupList.name : list.name;
                                groupList.periodId = string.IsNullOrWhiteSpace(list.periodId) ? groupList.periodId : list.periodId;
                                groupList.school = school;
                                groupList.scope = "school";
                                groupList.froms = 3;
                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync(groupList, groupList.id, new PartitionKey(groupList.code));
                            }
                            else
                            {
                                groupList = new GroupList()
                                {
                                    id = Guid.NewGuid().ToString(),
                                    code = $"GroupList-{school}",
                                    name = list.name,
                                    periodId = list.periodId,
                                    scope = "school",
                                    school = school,
                                    type = "teach",
                                    year = list.year,
                                    froms = 3
                                };
                                groupList = await GroupListService.CheckListNo(groupList, _azureCosmos, _dingDing, _option);
                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).CreateItemAsync(groupList, new PartitionKey(groupList.code));
                            }
                        }
                        if (groupList != null) {
                            groupLists.Add(groupList);
                        }
                    }
                    else
                    {
                        errorData.Add(new Dictionary<string, string> { { "group",list.name}, { "periodId",list.periodId} });
                        // return Ok(new { error = 2, msg ="学段不存在！" });
                    }
                }
            }
            else
            {
                return Ok(new { error = 3, msg = groupListsDto.Valid() });
            }
            return Ok(new { groupLists, errorData });
        }

        /// <summary>
        /// 导入教学班学生
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("import-teach-members")]
        [ApiToken(Auth = "1207", Name = "导入教学班学生", RW = "W", Limit = false)]
        public async Task<IActionResult> ImportTeachMembers(JsonElement json)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            if (!json.TryGetProperty("groupId", out JsonElement _groupId)) {    return Ok(new { error = 2, msg = "名单错误！" }); } 
            if(!json.TryGetProperty("members", out JsonElement _members)) return Ok(new { error = 1, msg = "名单列表格式错误" });
            if (_members.ValueKind.Equals(JsonValueKind.Array))
            {
                //School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                List<Member> members = _members.ToObject<List<Member>>();
                ValidResult valid = members.Valid();
                if (valid.isVaild)
                {
                    var tmds = members.Where(x => x.type == 1);
                    var stus = members.Where(x => x.type == 2);
                    List<Student> students = await StudentService.GeStudentData(_azureCosmos, school, stus?.Select(x => x.id));
                    List<TmdInfo> infos = null;
                    string tmdstr = "";
                    try
                    {
                        var content = new StringContent(tmds.Select(x => x.id).ToJsonString(), Encoding.UTF8, "application/json");
                        tmdstr = await _coreAPIHttpService.GetUserInfos(content);
                        infos = tmdstr.ToObject<List<TmdInfo>>();
                    }
                    catch (Exception ex)
                    {
                        await _dingDing.SendBotMsg($"{_coreAPIHttpService.options.Get("Default").location}用户转换失败：{_coreAPIHttpService.options.Get("Default").url}{tmdstr}\n {ex.Message}{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                        //return Ok(new { error =3, msg = "醍摩豆ID验证错误！" });
                    }
                    var unexist_student = stus.Select(x => x.id).Except(students.Select(y => y.id));
                    var unexist_tmdids = tmds.Select(x => x.id).Except(infos.Select(y => y.id));
                    Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{_groupId}", new PartitionKey($"GroupList-{school}"));
                    if (response.Status == 200)
                    {
                        JsonDocument jsonDocument = JsonDocument.Parse(response.Content);
                        var list =  jsonDocument.RootElement.ToObject<GroupList>();
                        if (list.type.Equals("teach") && list.school.Equals(school))
                        {
                            if (infos.Any())
                            {
                                infos.ToList().ForEach(x => {
                                    if (!list.members.Where(z => z.type == 1).Select(x => x.id).Contains(x.id))
                                    {
                                        GroupListService.JoinList(list, x.id , 1 , school);
                                    }
                                });
                            }
                            if (stus.Any()) 
                            {
                                stus.ToList().ForEach(x => {
                                    if (!list.members.Where(z => z.type == 2).Select(x => x.id).Contains(x.id)) {
                                        GroupListService.JoinList(list, x.id ,2 , school);
                                    }    
                                });
                            }
                            list = await GroupListService.CheckListNo(list, _azureCosmos, _dingDing, _option);
                            list = await GroupListService.UpsertList(list, _azureCosmos, _configuration, _serviceBus);
                            return Ok(new { unexist_student, unexist_tmdids, import_list=list });
                        }
                        else {
                            return Ok(new { error = 3, msg = $"名单类型不是教学班或者不是当前学校的名单！{list.type},{list.school}" });
                        }
                    }
                    else
                    {
                        return Ok(new { error = 2, msg = "名单错误！" });
                    }
                }
                else
                {
                    return Ok(new { error = 3, msg = valid });
                }
            }
            else
            {
                return Ok(new { error = 1, msg = "名单列表格式错误" });
            }
        }

        /// <summary>
        /// 移除教学班学生
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("remove-teach-members")]
        [ApiToken(Auth = "1208", Name = "移除教学班学生", RW = "W", Limit = false)]
        public async Task<IActionResult> RemoveTeachMembers(JsonElement json) {
            var (id, school) = HttpContext.GetApiTokenInfo();
            json.TryGetProperty("stuids", out JsonElement _stuids);
            json.TryGetProperty("tmdids", out JsonElement _tmdids);
            if (json.TryGetProperty("groupId", out JsonElement _groupId)) { return Ok(new { error = 1, msg = "名单错误！" }); }
            List<string> stuids = null;
            if (_stuids.ValueKind.Equals(JsonValueKind.Array)) {
                stuids = _stuids.ToObject<List<string>>();
            }
            List<string> tmdids = null;
            if (_tmdids.ValueKind.Equals(JsonValueKind.Array))
            {
                tmdids = _tmdids.ToObject<List<string>>();
            }
            if (tmdids.Any() || stuids.Any())
            {
                // School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{_groupId}", new PartitionKey($"GroupList-{school}"));
                if (response.Status == 200)
                { 
                    JsonDocument document= JsonDocument.Parse(response.Content);
                    var  list= document.RootElement.Deserialize<GroupList>();
                    List<string> remove_tmdids = new List<string>();
                    if (tmdids.Any()) {
                        tmdids.ForEach(x => {
                            int len= list.members.RemoveAll(z => z.id.Equals(x) && z.type == 1);
                            if (len > 0) {
                                remove_tmdids.Add(x);
                            }
                        });
                    }
                    List<string> remove_stuids = new List<string>();
                    if (stuids.Any())
                    {
                        stuids.ForEach(x => {
                            int len = list.members.RemoveAll(z => z.id.Equals(x) && z.type == 2);
                            if (len > 0)
                            {
                                remove_stuids.Add(x);
                            }
                        });
                    }
                    list = await GroupListService.UpsertList(list, _azureCosmos, _configuration, _serviceBus);
                    return Ok(new { remove_stuids, remove_tmdids, list });
                }
                else {
                    return Ok(new { error = 2, msg = "名单错误！" });
                }
            }
            else 
            {
                 return Ok(new { error = 2, msg = "移除的名单人员为空！" }); 
            }
        }
    }
}