TEAMModelOS/TEAMModelOS/Controllers/Both/CourseBaseController.cs

using Azure.Cosmos;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic; 
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.Models; 
using TEAMModelOS.SDK.Models; 
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension; 
using Azure; 
using Microsoft.Extensions.Configuration;
using TEAMModelOS.Filter; 
using HTEXLib.COMM.Helpers; 
using System.Globalization;
using TEAMModelOS.SDK;
using Microsoft.AspNetCore.Authorization;
using StackExchange.Redis;
using Azure.Storage.Blobs.Models;
using Microsoft.Azure.Amqp.Sasl;
using DocumentFormat.OpenXml.Drawing.Charts;
using FastJSON;
using OpenXmlPowerTools;
using DocumentFormat.OpenXml.Drawing.Spreadsheet;
using System.Text.RegularExpressions;
using System.Security.Claims;
using DocumentFormat.OpenXml.Bibliography;
using DocumentFormat.OpenXml.Spreadsheet;
using static SKIT.FlurlHttpClient.Wechat.TenpayV3.Models.CreateApplyForSubjectApplymentRequest.Types;

namespace TEAMModelOS.Controllers.Both
{
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]

    [Route("course-base")]
    [ApiController]
    public class CourseBaseController : ControllerBase
    {
        private AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        private readonly Option _option;
        private readonly AzureServiceBusFactory _serviceBus;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private static List<string> weekDays = new List<string> { "MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN" };
        public IConfiguration _configuration { get; set; }
        public CourseBaseController(AzureRedisFactory azureRedis, AzureCosmosFactory azureCosmos, DingDing dingDing, IOptionsSnapshot<Option> option, CoreAPIHttpService coreAPIHttpService, AzureServiceBusFactory serviceBus, AzureStorageFactory azureStorage, IConfiguration configuration)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _option = option?.Value;
            _serviceBus = serviceBus;
            _configuration = configuration;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis; _coreAPIHttpService = coreAPIHttpService;
        }
        /// <summary>
        /// 更新保存课程
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "teacher,admin")]
        [HttpPost("manage")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif
        public async Task<IActionResult> Manage(JsonElement request)
        {
            try
            {
                (string tmdid, _, _, string school) = HttpContext.GetAuthTokenInfo();
                if (!request.TryGetProperty("grant_type", out JsonElement grant_type)) return BadRequest();
                if (!request.TryGetProperty("scope", out JsonElement scope)) return BadRequest();
                var client = _azureCosmos.GetCosmosClient();
                switch (true)
                {
                    case bool when $"{grant_type}".Equals("list", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("code", out JsonElement _code))
                            {
                                return BadRequest();
                            }
                            if (!request.TryGetProperty("periodId", out JsonElement _periodId)) return BadRequest();
                            string tbname = $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? Constant.School : Constant.Teacher;
                            string partitionKey = $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? $"CourseBase-{_code}": "CourseBase";
                            string baseSql = $"select value c from c where c.period.id='{_periodId}'";
                            List<CourseBase> courseBases = new List<CourseBase>();
                            HashSet<string>teacherIds = new HashSet<string>();
                            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname)
                            .GetItemQueryIterator<CourseBase>(queryText: baseSql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey(partitionKey) }))
                            {
                                if (!string.IsNullOrWhiteSpace(item.creatorId)) {
                                    teacherIds.Add(item.creatorId);
                                }
                                courseBases.Add(item);
                            }
                            List<IdNameCode> teachers = new List<IdNameCode>();
                            if (teacherIds.Count>0) {
                                string teacherSQLBase = $"select     c.id,c.name,c.picture from c where  c.id   in ({string.Join(",", teacherIds.Select(z => $"'{z}'"))}) ";
                                var resultBase = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<IdNameCode>(teacherSQLBase, $"Base");
                                teachers = resultBase.list;
                            }
                            int studyYear = -1;
                            string semesterId = string.Empty;
                            if ($"{scope}".Equals("school")) {
                                if (!request.TryGetProperty("year", out JsonElement _year) || !request.TryGetProperty("semesterId", out JsonElement _semesterId))
                                {
                                    //如果没传，则以当前时间获取学年和学期信息
                                    School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                                    var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                                    (Semester currSemester, int studyYear, DateTimeOffset currSemesterDate, DateTimeOffset date, DateTimeOffset nextSemester) info = SchoolService.GetSemester(period);
                                    semesterId = info.currSemester.id;
                                    studyYear = info.studyYear;

                                }
                                else
                                {
                                    studyYear = _year.GetInt32();
                                    semesterId=_semesterId.GetString();
                                }
                            }
                            foreach (var z in courseBases) {
                                var teacher = teachers.Find(x => x.id.Equals(z.creatorId));
                                if (teacher!= null)
                                {
                                    z.creatorName=teacher.name;
                                    z.creatorPicture=teacher.picture;
                                }

                            }
                            return Ok(new { courseBases = courseBases.OrderByDescending(z => z._ts) });
                        }
                    case bool when $"{grant_type}".Equals("delete", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("id", out JsonElement _id)  || !request.TryGetProperty("code", out JsonElement _code))
                            {
                                return BadRequest();
                            }
                            string tbname = $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? Constant.School : Constant.Teacher;
                            string partitionKey = $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? $"CourseBase-{_code}" : "CourseBase";
                            Azure.Response response = await client.GetContainer(Constant.TEAMModelOS, tbname).DeleteItemStreamAsync(_id.ToString(), new PartitionKey(partitionKey));
                            //需要联动删除排课
                            string taskCode = $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? $"CourseTask-{_code}": "CourseTask";
                            string taskSql = $"select value c from c where c.courseId='{_id}'";
                            List<CourseTask> courseTasks = new List<CourseTask>();
                            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname)
                            .GetItemQueryIterator<CourseTask>(queryText: taskSql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey(taskCode) }))
                            {
                                courseTasks.Add(item);
                            }
                            if (courseTasks.Count > 0)
                            {
                                await client.GetContainer(Constant.TEAMModelOS, tbname).DeleteItemsStreamAsync(courseTasks.Select(x => x.id).ToList(), taskCode);
                            }
                            return Ok(new { code = response.Status });
                        }
                    case bool when $"{grant_type}".Equals("import-base", StringComparison.OrdinalIgnoreCase) && $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("courses", out JsonElement _courses))
                            {
                                return BadRequest();
                            }
                            if (!request.TryGetProperty("periodId", out JsonElement _periodId)) return BadRequest();
                            List<CourseBase> courseBases = _courses.ToObject<List<CourseBase>>();

                            var noNo = courseBases.Where(x => string.IsNullOrWhiteSpace(x.no));
                            if (noNo!=null &&noNo.Count()>0)
                            {
                                return Ok(new { code = 5, msg = "课程编号为空", courses = noNo });
                            }
                            var noName = courseBases.Where(x => string.IsNullOrWhiteSpace(x.name));
                            if (noName!=null &&noName.Count()>0)
                            {
                                return Ok(new { code = 6, msg = "课程名称，年级", courses = noName });
                            }
                            //1.检查导入的课程名称是否有效
                            StringBuilder sqlNo = new StringBuilder(" select  value c from c ");
                            sqlNo.Append($" where c.no in( {string.Join(",", courseBases.Select(z => $"'{z.no}'"))} )   and  c.period.id='{_periodId}' ");
                            string tbname = Constant.School;
                            List<CourseBase> courseBasesDB = new List<CourseBase>();
                            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname)
                            .GetItemQueryIterator<CourseBase>(queryText: sqlNo.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"CourseBase-{school}") }))
                            {
                                courseBasesDB.Add(item);
                            }
                            if (courseBasesDB.IsNotEmpty())
                            {
                                courseBases.RemoveAll(x => courseBasesDB.Select(y => y.no).Contains(x.no));
                            }
                            List<CourseBase> courseNameDuplicate = new List<CourseBase>();
                            School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                            var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                            if (period != null)
                            {
                                foreach (var item in courseBases)
                                {
                                    item.pk = "CourseBase";
                                    if (string.IsNullOrWhiteSpace(item.id))
                                    {
                                        item.id = Guid.NewGuid().ToString();
                                    }
                                    item.scope = "school";
                                    item.school = school;
                                    item.creatorId = tmdid;
                                    item.code = $"CourseBase-{school}";
                                    item.period = new IdName { id = period.id, name = period.name };
                                    if (!string.IsNullOrWhiteSpace(item.subject?.id))
                                    {
                                        var subject = period.subjects.Find(x => x.id.Equals(item.subject.id));
                                        if (subject != null)
                                        {
                                            item.subject.name = subject.name;
                                        }
                                        else
                                        {
                                            return Ok(new { code = 1, msg = "科目不存在", course = item });
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 1, msg = "科目不存在", course = item });
                                    }
                                    if (!string.IsNullOrWhiteSpace(item.major?.id))
                                    {
                                        var major = period.majors.Find(x => x.id.Equals(item.major.id));
                                        if (major != null)
                                        {
                                            item.major.name = major.name;
                                        }
                                        else
                                        {
                                            return Ok(new { code = 2, msg = "专业不存在", course = item });
                                        }
                                    }

                                    StringBuilder sqlName = new StringBuilder(" select  value c from c ");
                                    sqlName.Append($" where c.name='{item.name}' and c.grade={item.grade} and  c.period.id='{_periodId}' ");
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseBase>(sqlName.ToString(), item.code);
                                    if (result.list.IsNotEmpty())
                                    {
                                        courseNameDuplicate.Add(item);

                                    }
                                    else { await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).UpsertItemAsync(item, new PartitionKey(item.code)); }
                                }
                                return Ok(new { course = courseBases, courseNoDuplicate = courseBasesDB, courseNameDuplicate });
                            }
                            else
                            {
                                return Ok(new { code = 3, msg = "学段不存在", });
                            }

                        }
                    case bool when $"{grant_type}".Equals("upsert", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("course", out JsonElement _course))
                            {
                                return BadRequest();
                            }
                            CourseBase courseBase = _course.ToObject<CourseBase>();
                            courseBase.pk = "CourseBase";

                            string tbname = $"{courseBase.scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? Constant.School : Constant.Teacher;
                            //1.检查导入的课程名称是否有效
                            StringBuilder sqlCourse = new StringBuilder(" select  value c from c ");
                            if (courseBase.scope.Equals("school", StringComparison.OrdinalIgnoreCase))
                            {
                                courseBase.school = school;
                                courseBase.creatorId = tmdid;
                                courseBase.code = $"CourseBase-{school}";
                                if (string.IsNullOrWhiteSpace(courseBase.subject?.id)  ||courseBase.grade<0)
                                {
                                    return BadRequest();
                                }
                                if (string.IsNullOrWhiteSpace(courseBase.period?.id))
                                {
                                    return BadRequest();
                                }
                                else
                                {
                                    if (string.IsNullOrWhiteSpace(courseBase.id))
                                    {
                                        if (string.IsNullOrWhiteSpace(courseBase.no))
                                        {
                                            School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                                            var period = schoolBase.period.Find(x => x.id.Equals($"{courseBase.period.id}"));

                                            //生成新的课程编号
                                            string sqlNo = $"select  value c.no from c where c.period.id='{courseBase.period.id}'  ";
                                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).GetList<string>(sqlNo, courseBase.code);
                                            if (result.list.IsNotEmpty())
                                            {
                                                int index = period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))+1;
                                                var nos = result.list.FindAll(x => !string.IsNullOrWhiteSpace(x) &&  x.StartsWith($"{index}")).ToHashSet<string>();
                                                if (nos != null)
                                                {
                                                    string couresNo = string.Empty;
                                                    List<string> order = nos.Where(y => !string.IsNullOrEmpty(y) && Regex.IsMatch(y, @"^\d*$")).OrderBy(x => int.Parse(x)).ToList();
                                                    if (!order.Contains($"{index}00"))
                                                    {
                                                        order.Insert(0, $"{index}00");
                                                    }
                                                    if (order != null)
                                                    {
                                                        if (!order.Contains($"{index}00"))
                                                        {
                                                            order.Insert(0, $"{index}00");
                                                        }
                                                    }
                                                    else { order = new List<string>() { $"{index}00" }; }
                                                    for (int i = 0; i < order.Count; i++)
                                                    {
                                                        couresNo = $"{int.Parse(order[i]) + 1}";
                                                        int no = i + 1;
                                                        if (no <= order.Count - 1)
                                                        {
                                                            if (!couresNo.Equals(order[no]))
                                                            {
                                                                break;
                                                            }
                                                        }
                                                    }
                                                    if (string.IsNullOrWhiteSpace(couresNo))
                                                    {
                                                        couresNo=$"{index}99";
                                                    }
                                                    courseBase.no=couresNo;
                                                }
                                                else
                                                {
                                                    courseBase.no= $"{index}01";
                                                }
                                            }
                                            else
                                            {
                                                courseBase.no= $"{(period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))+1)}01";
                                            }
                                        }
                                    }
                                    else
                                    {
                                        if (string.IsNullOrWhiteSpace(courseBase.no))
                                        {
                                            //编辑时，编号不能为空
                                            return Ok(new { code = 6, course = courseBase });
                                        }
                                    }

                                    sqlCourse.Append($" where c.no ='{courseBase.no}'    ");
                                    sqlCourse.Append($" and  c.period.id='{courseBase.period.id}' ");
                                }
                            }
                            else
                            {
                                sqlCourse.Append($" where c.name ='{courseBase.name}' and c.creatorId='{tmdid}' ");
                                courseBase.creatorId = tmdid;
                                courseBase.code = $"CourseBase";
                            }
                            List<CourseBase> courseBases = new List<CourseBase>();
                            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname)
                            .GetItemQueryIterator<CourseBase>(queryText: sqlCourse.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey(courseBase.code) }))
                            {
                                if (courseBase.scope.Equals(item.scope))
                                {
                                    if (courseBase.scope.Equals("school", StringComparison.OrdinalIgnoreCase))
                                    {
                                        //不是同一条数据，但是编号相同，则判定编号重复。
                                        if (!string.IsNullOrWhiteSpace(courseBase.id))
                                        {
                                            if (!item.id.Equals(courseBase.id) && item.no.Equals(courseBase.no))
                                            {
                                                return Ok(new { code = 4, course = courseBase });
                                            }
                                        }
                                        else
                                        {
                                            if (item.no.Equals(courseBase.no))
                                            {
                                                return Ok(new { code = 4, course = courseBase });
                                            }
                                        }

                                    }
                                    else
                                    {
                                        //不是同一条数据，但是名称相同，则判定名字重复。
                                        if (!item.id.Equals(courseBase.id) && item.name.Equals(courseBase.name))
                                        {
                                            return Ok(new { code = 5, course = courseBase });
                                        }
                                    }

                                }
                            }
                            if (courseBase.scope.Equals("school", StringComparison.OrdinalIgnoreCase))
                            {
                                string sqlNameGrade = $"select value c from c where c.name ='{courseBase.name}' and c.grade={courseBase.grade} and c.period.id='{courseBase.period.id}' ";
                                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname)
                                    .GetItemQueryIterator<CourseBase>(queryText: sqlNameGrade, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey(courseBase.code) }))
                                {
                                    //不是同一条数据，但是名字年级重复
                                    if (!string.IsNullOrWhiteSpace(courseBase.id))
                                    {
                                        if (!item.id.Equals(courseBase.id) && item.name.Equals(courseBase.name) && item.grade== courseBase.grade)
                                        {
                                            //名字和年级重复
                                            return Ok(new { code = 5, course = courseBase });
                                        }

                                    }
                                    else
                                    {
                                        if (item.name.Equals(courseBase.name) && item.grade== courseBase.grade)
                                        {
                                            //名字和年级重复
                                            return Ok(new { code = 5, course = courseBase });
                                        }
                                    }
                                }
                            }
                            if (string.IsNullOrWhiteSpace(courseBase.id))
                            {
                                courseBase.id = Guid.NewGuid().ToString();
                            }
                            await client.GetContainer(Constant.TEAMModelOS, tbname).UpsertItemAsync(courseBase, new PartitionKey(courseBase.code));
                            try
                            {
                                Teacher teacher = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemAsync<Teacher>(courseBase.creatorId, new PartitionKey("Base"));
                                courseBase.creatorName= teacher.name;
                                courseBase.creatorPicture=teacher.picture;
                            } catch {
                                courseBase.creatorName=courseBase.creatorId;
                            }
                            return Ok(new { code = 200, course = courseBase });
                        }
                    case bool when $"{grant_type}".Equals("read-task", StringComparison.OrdinalIgnoreCase):
                        {

                            if (!request.TryGetProperty("courseId", out JsonElement _courseId)) return BadRequest();

                            string tbname = $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? Constant.School : Constant.Teacher;
                            if (scope.ToString().Equals("school", StringComparison.OrdinalIgnoreCase))
                            {

                                if (!request.TryGetProperty("periodId", out JsonElement _periodId)) return BadRequest();
                                int studyYear = -1;
                                string semesterId = string.Empty;
                                School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                                var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                                if (!request.TryGetProperty("year", out JsonElement _year) || !request.TryGetProperty("semesterId", out JsonElement _semesterId))
                                {
                                    //如果没传，则以当前时间获取学年和学期信息
                                    (Semester currSemester, int studyYear, DateTimeOffset currSemesterDate, DateTimeOffset date, DateTimeOffset nextSemester) info = SchoolService.GetSemester(period);
                                    semesterId = info.currSemester.id;
                                    studyYear = info.studyYear;
                                }
                                else
                                {
                                    studyYear = _year.GetInt32();
                                    semesterId=_semesterId.GetString();
                                }
                                HashSet<string> groupIds = new HashSet<string>();
                                HashSet<string> teacherIds = new HashSet<string>();
                                HashSet<string> roomIds = new HashSet<string>();
                                List<GroupListDto> groups = new List<GroupListDto>();
                                string taskCode = $"CourseTask-{school}";
                                string taskId = $"{studyYear}-{semesterId}-{_courseId}";
                                Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).ReadItemStreamAsync(taskId, new PartitionKey(taskCode));
                                bool has_schedule = false;
                                CourseTask courseTask = default;
                                if (response.Status == 200)
                                {
                                    courseTask=JsonDocument.Parse(response.Content).RootElement.ToObject<CourseTask>();
                                    if (courseTask != null && courseTask.schedules.IsNotEmpty())
                                    {
                                        foreach (var schedule in courseTask.schedules) {
                                            if (!string.IsNullOrWhiteSpace(schedule.groupId))
                                            {
                                                groupIds.Add(schedule.groupId);
                                            }
                                            if (!string.IsNullOrWhiteSpace(schedule.teacherId))
                                            {
                                                teacherIds.Add(schedule.teacherId);
                                            }
                                            if (!string.IsNullOrWhiteSpace(schedule.roomId))
                                            {
                                                roomIds.Add(schedule.roomId);
                                            }
                                            if (schedule.assistants!=null  && schedule.assistants.Count>0) {
                                                teacherIds.UnionWith(schedule.assistants);
                                            }
                                        }
                                        has_schedule = true;
                                    }
                                }
                                //匹配建议的班级和教师
                                List<Class> classes = new List<Class>();
                                List<SchoolTeacher> teachers = new List<SchoolTeacher>();
                                List<IdNameCode> teachersBases = new List<IdNameCode>();
                                if (!has_schedule)
                                {
                                    //如果没有找到排课安排信息。则可以进行建议升学年方式处理
                                    CourseBase courseBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<CourseBase>(_courseId.ToString(), new PartitionKey($"CourseBase-{school}"));
                                    if (courseBase.grade>=0)
                                    {
                                        var yearsdata = SchoolService.GetYears(schoolBase, _periodId.ToString(), new List<int> { courseBase.grade });
                                        List<int> years = yearsdata.years.ToList();
                                        if (years.IsNotEmpty())
                                        {
                                            StringBuilder sql = new StringBuilder($"select value c from  c where c.year in ({string.Join(",", years)}) and c.periodId='{_periodId}' ");
                                            var result = await client.GetContainer(Constant.TEAMModelOS, Constant.School).GetList<Class>(sql.ToString(), $"Class-{school}");
                                            classes = result.list;
                                        }
                                    }
                                    if (!string.IsNullOrWhiteSpace(courseBase.subject?.id))
                                    {
                                        string teacherSQL = $"select distinct value c from c join b in c.subjectIds  where b in ('{courseBase.subject.id}') and  c.code = 'Teacher-{school}'";
                                        var result = await client.GetContainer(Constant.TEAMModelOS, Constant.School).GetList<SchoolTeacher>(teacherSQL, $"Teacher-{school}");
                                        teachers = result.list;
                                    }
                                }else
                                {
                                    var groupList =   await GroupListService.GetMemberByListids(_coreAPIHttpService,  _azureCosmos.GetCosmosClient(), _dingDing, groupIds.ToList(), school);
                                    groups= groupList.groups.Select(z => new GroupListDto(z)).ToList();
                                    string teacherSQLBase = $"select     c.id,c.name,c.picture from c where  c.id   in ({string.Join(",", teacherIds.Select(z => $"'{z}'"))}) ";
                                    var resultBase = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<IdNameCode>(teacherSQLBase, $"Base");
                                    teachersBases = resultBase.list;
                                }
                                int count = 0;
                                if (groups.IsNotEmpty())
                                {
                                    count = courseTask.schedules.RemoveAll(z => !string.IsNullOrWhiteSpace(z.groupId)  &&  !groups.Select(v => v.id).Contains(z.groupId));
                                    if (count>0)
                                    {
                                        await client.GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(courseTask, new PartitionKey(courseTask.code));
                                    }
                                }
                                else {
                                    if (has_schedule) {
                                        count = courseTask.schedules.RemoveAll(z => !string.IsNullOrWhiteSpace(z.groupId)  );
                                        //排课任务的所有名单都不在。
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).DeleteItemStreamAsync(courseTask.id, new PartitionKey(courseTask.code));
                                    }
                                }
                                //当courseTask 为空，则matchedClasses可能会有年级匹配建议升学年的班级清单，
                                //注：比如高二可能会将高三的课程学完，则该高三的课程的学年级应该是手动处理为高中二年级。不区分学期的目的，也是可能存在提前一学期学完第二学期的课程。
                                return Ok(new {count= count, studyYear, semesterId, courseTask, teachers= teachersBases, groups, matchedClasses = classes, matchedTeachers = teachers.Select(z => new { z.id, z.name, z.subjectIds, z.job, z.periodId, z.picture }) });
                            }
                            else
                            {
                                string taskCode = $"CourseTask";
                                string taskId = $"{_courseId}";
                                Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).ReadItemStreamAsync(taskId, new PartitionKey(taskCode));
                                CourseTask courseTask = default;
                                if (response.Status == 200)
                                {
                                    courseTask = JsonDocument.Parse(response.Content).RootElement.ToObject<CourseTask>();
                                }
                                return Ok(new { courseTask });
                            }
                        }

                    case bool when $"{grant_type}".Equals("upsert-scheduleTask", StringComparison.OrdinalIgnoreCase):
                        {
                            List<ScheduleTaskDto> invalidCourseTask = new List<ScheduleTaskDto>();
                            JsonElement _year = default, _semesterId = default, _courseId = default, _periodId = default;
                            if (!request.TryGetProperty("courseId", out _courseId))
                            {
                                return BadRequest();
                            }
                            if (!request.TryGetProperty("datas", out JsonElement _datas))
                            {
                                return BadRequest();
                            }
                            if ($"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase))
                            {
                                if (!request.TryGetProperty("periodId", out _periodId)) return BadRequest();
                                if (!request.TryGetProperty("year", out _year))
                                {
                                    return BadRequest();
                                }
                                if (!request.TryGetProperty("semesterId", out _semesterId))
                                {
                                    return BadRequest();
                                }
                            }
                            string tbname = $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? Constant.School : Constant.Teacher;
                            List<ScheduleTaskDto> datas = _datas.ToObject<List<ScheduleTaskDto>>();
                            //过滤掉名单，教师空的数据
                            var invalids = datas.FindAll(z => string.IsNullOrWhiteSpace(z.teacherId) || string.IsNullOrWhiteSpace(z.groupId) || string.IsNullOrWhiteSpace(z.type));
                            if (invalids != null)
                            {
                                datas.RemoveAll(z => string.IsNullOrWhiteSpace(z.teacherId) || string.IsNullOrWhiteSpace(z.groupId) || string.IsNullOrWhiteSpace(z.type));
                                foreach (var invalid in invalids)
                                {
                                    if (string.IsNullOrWhiteSpace(invalid.groupId) || string.IsNullOrWhiteSpace(invalid.type))
                                    {
                                        invalid.invalidCode = 3;
                                    }
                                    if (string.IsNullOrWhiteSpace(invalid.teacherId))
                                    {
                                        invalid.invalidCode = 2;
                                    }
                                    invalidCourseTask.Add(invalid);
                                }
                            }
                            var groups = datas.GroupBy(z => new { z.teacherId, z.groupId }).Select(x => new { key = x.Key, list = x.ToList() });
                            foreach (var item in groups)
                            {
                                if (item.list.Count > 1)
                                {
                                    return Ok(new { invalidCourseTask = item.list.Select(z => z.invalidCode=20) });//同一教师，同一班级，同一课程，只能有一条记录
                                }
                            }
                            HashSet<CourseTask> courseTasks = new HashSet<CourseTask>();
                            if (scope.ToString().Equals("school", StringComparison.OrdinalIgnoreCase))
                            {
                                string taskCode = $"CourseTask-{school}";
                                string taskId = $"{_year}-{_semesterId}-{_courseId}";
                                CourseTask courseTask = null;
                                School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                                var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));

                                //学年
                                if (int.Parse(_year.ToString()) < 2000)
                                {
                                    return Ok(new { invalidCode = 17 });//学年应大于2000
                                }
                                //学期
                                var semester = period.semesters.Where(z => z.id.Equals(_semesterId.ToString()));
                                if (!semester.Any())
                                {
                                    return Ok(new { invalidCode = 16 });//学期不存在
                                }
                                CourseBase courseBase = null;
                                Azure.Response responseBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync($"{_courseId.ToString()}", new PartitionKey($"CourseBase-{school}"));
                                if (responseBase.Status == 200)
                                {
                                    courseBase = JsonDocument.Parse(responseBase.Content).RootElement.ToObject<CourseBase>();
                                }
                                else
                                {
                                    return Ok(new { invalidCode = 1 });//课程不存在
                                }
                                Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync(taskId, new PartitionKey(taskCode));
                                if (response.Status == 200)
                                {
                                    courseTask = JsonDocument.Parse(response.Content).RootElement.ToObject<CourseTask>();
                                }
                                else
                                {
                                    courseTask = new CourseTask
                                    {
                                        id = taskId,
                                        code = taskCode,
                                        pk = "CourseTask",
                                        ttl = -1,
                                        courseId = _courseId.ToString(),
                                        year = int.Parse(_year.ToString()),
                                        semesterId = _semesterId.ToString(),
                                    };
                                }
                                //获取相关的名单
                                List<GroupListDto> groupListDtos = await GroupListService.GetGroupListByListids(client, _dingDing, datas.Select(z => z.groupId).ToHashSet().ToList(), school);
                                //获取相关的教室
                                var roomIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.roomId)).Select(c => $"'{c.roomId}'");
                                List<Room> rooms = new List<Room>();
                                if (roomIds.Any())
                                {
                                    string sqlRoom = $"select value c from c where c.id in ({string.Join(",", roomIds)})";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<Room>(sqlRoom, $"Room-{school}");
                                    if (result.list.IsNotEmpty())
                                    {
                                        rooms.AddRange(result.list);
                                    }
                                }
                                //获取教师
                                List<SchoolTeacher> schoolTeachers = new List<SchoolTeacher>();
                                var teacherIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.teacherId)).Select(c => c.teacherId);
                                var assistants = datas.SelectMany(x => x.assistants);
                                teacherIds = teacherIds.Union(assistants).ToHashSet();
                                if (teacherIds.Any())
                                {
                                    string sqlTeacher = $"select value c from c where c.id in ({string.Join(",", teacherIds.Select(x => $"'{x}'"))}) ";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<SchoolTeacher>(sqlTeacher, $"Teacher-{school}");
                                    if (result.list.IsNotEmpty())
                                    {
                                        schoolTeachers.AddRange(result.list);
                                    }
                                }
                                foreach (var data in datas)
                                {
                                    var courseTaskInsert = SchoolService.CheckCourseTask($"{scope}", data, school, groupListDtos, rooms, schoolTeachers, null);
                                    if (courseTaskInsert.invalidCode == 0)
                                    {


                                        var scheduleTask = courseTask.schedules.Find(z => z.type.Equals(courseTaskInsert.type) && z.groupId.Equals(courseTaskInsert.groupId));
                                        if (scheduleTask == null)
                                        {
                                            scheduleTask = new ScheduleTask()
                                            {
                                                roomId = courseTaskInsert.roomId,
                                                groupId = courseTaskInsert.groupId,
                                                type = courseTaskInsert.type,
                                                teacherId = courseTaskInsert.teacherId,
                                                times = new List<ScheduleTime>(),
                                                school = school,
                                                assistants = courseTaskInsert.assistants != null ? courseTaskInsert.assistants : new HashSet<string>()
                                            };
                                            courseTask.schedules.Add(scheduleTask);
                                            //新增
                                        }
                                        else
                                        {
                                            //编辑
                                            scheduleTask.roomId = courseTaskInsert.roomId;
                                            scheduleTask.school = school;
                                            scheduleTask.teacherId = courseTaskInsert.teacherId;
                                            scheduleTask.startTime= courseTaskInsert.startTime>0 ? courseTaskInsert.startTime : scheduleTask.startTime;
                                            scheduleTask.notice=string.IsNullOrWhiteSpace(courseTaskInsert.notice) ? scheduleTask.notice : courseTaskInsert.notice;
                                            scheduleTask.assistants= courseTaskInsert.assistants!=null ? courseTaskInsert.assistants : scheduleTask.assistants;
                                        }
                                        //如果被删除完了，就删除该条记录。
                                        if (courseTask.schedules.Count <= 0)
                                        {
                                            courseTasks.Remove(courseTask);
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).DeleteItemStreamAsync(courseTask.id, new PartitionKey(courseTask.code));
                                        }
                                        else
                                        {
                                            courseTasks.Add(courseTask);
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(courseTask, new PartitionKey(taskCode));
                                        }
                                    }
                                    else
                                    {
                                        invalidCourseTask.Add(courseTaskInsert);
                                    }
                                }
                            }
                            else
                            {
                                string taskCode = $"CourseTask";
                                string taskId = $"{_courseId}";
                                CourseTask courseTask = null;
                                CourseBase courseBase = null;
                                Azure.Response responseBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync($"{_courseId.ToString()}", new PartitionKey($"CourseBase"));
                                if (responseBase.Status == 200)
                                {
                                    courseBase = JsonDocument.Parse(responseBase.Content).RootElement.ToObject<CourseBase>();
                                }
                                else
                                {
                                    return Ok(new { invalidCode = 1 });//课程不存在
                                }
                                Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(taskId, new PartitionKey(taskCode));
                                if (response.Status == 200)
                                {
                                    courseTask = JsonDocument.Parse(response.Content).RootElement.ToObject<CourseTask>();
                                }
                                else
                                {
                                    courseTask = new CourseTask
                                    {
                                        id = taskId,
                                        code = taskCode,
                                        pk = "CourseTask",
                                        ttl = -1,
                                        courseId = _courseId.ToString(),
                                        year = int.Parse(_year.ToString()),
                                        semesterId = _semesterId.ToString(),
                                    };
                                }
                                //获取相关的名单
                                List<GroupListDto> groupListDtos = await GroupListService.GetGroupListByListids(client, _dingDing, datas.Select(z => z.groupId).ToHashSet().ToList(), school);
                                //获取相关的教室
                                var roomIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.roomId)).Select(c => $"'{c.roomId}'");
                                List<Room> rooms = new List<Room>();
                                if (roomIds.Any()  && !string.IsNullOrWhiteSpace(school))
                                {
                                    string sqlRoom = $"select value c from c where c.id in ({string.Join(",", roomIds)})";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<Room>(sqlRoom, $"Room-{school}");
                                    if (result.list.IsNotEmpty())
                                    {
                                        rooms.AddRange(result.list);
                                    }
                                }
                                //获取教师
                                List<Teacher> teachers = new List<Teacher>();
                                var teacherIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.teacherId)).Select(x => x.teacherId);
                                var assistants = datas.SelectMany(x => x.assistants);
                                teacherIds = teacherIds.Union(assistants).ToHashSet();
                                if (teacherIds.Any())
                                {
                                    string sqlTeacher = $"select value c from c where c.id in ({string.Join(",", teacherIds.Select(x => $"'{x}'"))}) ";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<Teacher>(sqlTeacher, $"Base");
                                    if (result.list.IsNotEmpty())
                                    {
                                        teachers.AddRange(result.list);
                                    }
                                }
                                foreach (var data in datas)
                                {
                                    var courseTaskInsert = SchoolService.CheckCourseTask($"{scope}", data, school, groupListDtos, rooms, null, teachers);
                                    if (courseTaskInsert.invalidCode == 0)
                                    {


                                        var scheduleTask = courseTask.schedules.Find(z => z.type.Equals(courseTaskInsert.type) && z.groupId.Equals(courseTaskInsert.groupId));
                                        if (scheduleTask == null)
                                        {
                                            scheduleTask = new ScheduleTask()
                                            {
                                                roomId = courseTaskInsert.roomId,
                                                groupId = courseTaskInsert.groupId,
                                                type = courseTaskInsert.type,
                                                teacherId = courseTaskInsert.teacherId,
                                                times = new List<ScheduleTime>(),
                                                school = school,
                                            };
                                            courseTask.schedules.Add(scheduleTask);
                                            //新增
                                        }
                                        else
                                        {
                                            //编辑

                                            scheduleTask.roomId = courseTaskInsert.roomId;
                                            scheduleTask.school = school;
                                            scheduleTask.teacherId = courseTaskInsert.teacherId;
                                            scheduleTask.startTime = courseTaskInsert.startTime > 0 ? courseTaskInsert.startTime : scheduleTask.startTime;
                                            scheduleTask.notice = string.IsNullOrWhiteSpace(courseTaskInsert.notice) ? scheduleTask.notice : courseTaskInsert.notice;
                                            scheduleTask.assistants = courseTaskInsert.assistants != null ? courseTaskInsert.assistants : courseTaskInsert.assistants;
                                        }
                                        //如果被删除完了，就删除该条记录。
                                        if (courseTask.schedules.Count <= 0)
                                        {
                                            courseTasks.Remove(courseTask);
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).DeleteItemStreamAsync(courseTask.id, new PartitionKey(courseTask.code));
                                        }
                                        else
                                        {
                                            courseTasks.Add(courseTask);
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(courseTask, new PartitionKey(taskCode));
                                        }
                                    }
                                    else
                                    {
                                        invalidCourseTask.Add(courseTaskInsert);
                                    }
                                }
                            }
                            return Ok(new { invalidCourseTask, courseTasks });
                        }
                    case bool when $"{grant_type}".Equals("insert-scheduleTask", StringComparison.OrdinalIgnoreCase)
                                    || $"{grant_type}".Equals("change-scheduleTask", StringComparison.OrdinalIgnoreCase)
                                    || $"{grant_type}".Equals("delete-scheduleTask", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("datas", out JsonElement _datas))
                            {
                                return BadRequest();
                            }
                            string tbname = $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? Constant.School : Constant.Teacher;
                            List<CourseTaskChanged> datas = _datas.ToObject<List<CourseTaskChanged>>();
                            if (scope.ToString().Equals("school", StringComparison.OrdinalIgnoreCase))
                            {
                                if (!request.TryGetProperty("periodId", out JsonElement _periodId)) return BadRequest();
                                //获取相关的名单
                                List<GroupListDto> groupListDtos = await GroupListService.GetGroupListByListids(client, _dingDing, datas.Select(z => z.groupId).ToHashSet().ToList(), school);
                                //获取相关的教室
                                var roomIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.roomId)).Select(c => $"'{c.roomId}'");
                                List<Room> rooms = new List<Room>();
                                if (roomIds.Any())
                                {
                                    string sqlRoom = $"select value c from c where c.id in ({string.Join(",", roomIds)})";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<Room>(sqlRoom, $"Room-{school}");
                                    if (result.list.IsNotEmpty())
                                    {
                                        rooms.AddRange(result.list);
                                    }
                                }
                                //获取教师
                                List<SchoolTeacher> schoolTeachers = new List<SchoolTeacher>();
                                var teacherIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.teacherId)).Select(c => $"'{c.teacherId}'");
                                if (teacherIds.Any())
                                {
                                    string sqlTeacher = $"select value c from c where c.id in ({string.Join(",", teacherIds)}) ";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<SchoolTeacher>(sqlTeacher, $"Teacher-{school}");
                                    if (result.list.IsNotEmpty())
                                    {
                                        schoolTeachers.AddRange(result.list);
                                    }
                                }
                                //获取课程
                                List<CourseBase> courseBases = new List<CourseBase>();
                                var courseIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.courseId)).Select(c => $"'{c.courseId}'");
                                if (courseIds.Any())
                                {
                                    string sqlCourse = $"select value c from c where c.id in ({string.Join(",", courseIds)}) ";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseBase>(sqlCourse, $"CourseBase-{school}");
                                    if (result.list.IsNotEmpty())
                                    {
                                        courseBases.AddRange(result.list);
                                    }
                                }
                                School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                                var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                                HashSet<CourseTask> courseTasks = new HashSet<CourseTask>();
                                List<CourseTaskChanged> invalidCourseTaskInsert = new List<CourseTaskChanged>();
                                foreach (var data in datas)
                                {
                                    var courseTaskInsert = SchoolService.CheckCourseTaskInsertOrChanged($"{grant_type}", scope.ToString(), data, school, period, courseBases, groupListDtos, rooms, schoolTeachers, null);
                                    if (courseTaskInsert.invalidCode == 0)
                                    {
                                        string taskCode = $"CourseTask-{school}";
                                        string taskId = $"{courseTaskInsert.year}-{courseTaskInsert.semesterId}-{courseTaskInsert.courseId}";
                                        CourseTask courseTask = courseTasks.Where(z => z.id.Equals(taskId) && z.code.Equals(taskCode)).FirstOrDefault();
                                        if (courseTask == null)
                                        {
                                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync(taskId, new PartitionKey(taskCode));
                                            if (response.Status == 200)
                                            {
                                                courseTask = JsonDocument.Parse(response.Content).RootElement.ToObject<CourseTask>();
                                            }
                                            else
                                            {
                                                courseTask = new CourseTask
                                                {
                                                    id = taskId,
                                                    code = taskCode,
                                                    pk = "CourseTask",
                                                    ttl = -1,
                                                    courseId = courseTaskInsert.courseId,
                                                    year = courseTaskInsert.year,
                                                    semesterId = courseTaskInsert.semesterId,
                                                    schedules = new List<ScheduleTask> { new ScheduleTask {
                                                        roomId = courseTaskInsert.roomId,
                                                        groupId = courseTaskInsert.groupId,
                                                        type = courseTaskInsert.type,
                                                        teacherId = courseTaskInsert.teacherId,
                                                        notice=courseTaskInsert.notice,
                                                        startTime = courseTaskInsert.startTime,
                                                        times= new List<ScheduleTime>(),
                                                        school=school,
                                                    } }
                                                };
                                            }
                                        }
                                        ScheduleTask scheduleTask = null;
                                        var scheduleTasks = courseTask.schedules.FindAll(z => z.type.Equals(courseTaskInsert.type) && z.groupId.Equals(courseTaskInsert.groupId));
                                        if (scheduleTasks.IsNotEmpty())
                                        {
                                            if (scheduleTasks.Count > 2)
                                            {
                                                courseTask.schedules.RemoveRange(1, scheduleTasks.Count - 1);
                                            }
                                            scheduleTask= scheduleTasks.First();
                                            scheduleTask.roomId = courseTaskInsert.roomId;
                                            scheduleTask.school = school;
                                            scheduleTask.teacherId = courseTaskInsert.teacherId;
                                            scheduleTask.startTime = courseTaskInsert.startTime > 0 ? courseTaskInsert.startTime : scheduleTask.startTime;
                                            scheduleTask.notice = string.IsNullOrWhiteSpace(courseTaskInsert.notice) ? scheduleTask.notice : courseTaskInsert.notice;
                                            scheduleTask.assistants = courseTaskInsert.assistants != null ? courseTaskInsert.assistants : courseTaskInsert.assistants;
                                        }
                                        else
                                        {
                                            scheduleTask = new ScheduleTask()
                                            {
                                                roomId = courseTaskInsert.roomId,
                                                groupId = courseTaskInsert.groupId,
                                                type = courseTaskInsert.type,
                                                teacherId = courseTaskInsert.teacherId,
                                                times = new List<ScheduleTime>(),
                                                school = school,
                                            };
                                            courseTask.schedules.Add(scheduleTask);
                                        }
                                        //修改教师或名单
                                        if (grant_type.ToString().Equals("change-scheduleTask", StringComparison.OrdinalIgnoreCase))
                                        {
                                            if (!string.IsNullOrWhiteSpace(courseTaskInsert.teacherIdChanged))
                                            {
                                                scheduleTask.teacherId = courseTaskInsert.teacherIdChanged;
                                            }
                                            if (!string.IsNullOrWhiteSpace(courseTaskInsert.typeChanged) && !string.IsNullOrWhiteSpace(courseTaskInsert.groupIdChanged))
                                            {
                                                scheduleTask.groupId = courseTaskInsert.groupIdChanged;
                                                scheduleTask.type = courseTaskInsert.typeChanged;
                                            }
                                        }
                                        //删除教师及名单的排课信息
                                        if (grant_type.ToString().Equals("delete-scheduleTask", StringComparison.OrdinalIgnoreCase))
                                        {
                                            courseTask.schedules.Remove(scheduleTask);
                                        }
                                        //如果被删除完了，就删除该条记录。
                                        if (courseTask.schedules.Count <= 0)
                                        {
                                            courseTasks.Remove(courseTask);
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).DeleteItemStreamAsync(courseTask.id, new PartitionKey(courseTask.code));
                                        }
                                        else
                                        {
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(courseTask, new PartitionKey(taskCode));
                                        }
                                    }
                                    else
                                    {
                                        invalidCourseTaskInsert.Add(courseTaskInsert);
                                    }
                                }
                                return Ok(new { invalidCourseTaskInsert, courseTasks });
                            }
                            else
                            {
                                //获取相关的名单
                                List<GroupListDto> groupListDtos = await GroupListService.GetGroupListByListids(client, _dingDing, datas.Select(z => z.groupId).ToHashSet().ToList(), school);
                                //获取相关的教室
                                var roomIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.roomId)).Select(c => $"'{c.roomId}'");
                                List<Room> rooms = new List<Room>();
                                if (roomIds.Any() && !string.IsNullOrWhiteSpace(school))
                                {
                                    string sqlRoom = $"select value c from c where c.id in ({string.Join(",", roomIds)})";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<Room>(sqlRoom, $"Room-{school}");
                                    if (result.list.IsNotEmpty())
                                    {
                                        rooms.AddRange(result.list);
                                    }
                                }
                                //获取教师
                                List<Teacher> teachers = new List<Teacher>();
                                var teacherIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.teacherId)).Select(c => $"'{c.teacherId}'");
                                if (teacherIds.Any())
                                {
                                    string sqlTeacher = $"select value c from c where c.id in ({string.Join(",", teacherIds)}) ";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<Teacher>(sqlTeacher, $"Base");
                                    if (result.list.IsNotEmpty())
                                    {
                                        teachers.AddRange(result.list);
                                    }
                                }
                                //获取课程
                                List<CourseBase> courseBases = new List<CourseBase>();
                                var courseIds = datas.Where(x => !string.IsNullOrWhiteSpace(x.courseId)).Select(c => $"'{c.courseId}'");
                                if (courseIds.Any())
                                {
                                    string sqlCourse = $"select value c from c where c.id in ({string.Join(",", courseIds)}) and c.creatorId='{tmdid}' ";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<CourseBase>(sqlCourse, $"CourseBase");
                                    if (result.list.IsNotEmpty())
                                    {
                                        courseBases.AddRange(result.list);
                                    }
                                }
                                HashSet<CourseTask> courseTasks = new HashSet<CourseTask>();
                                List<CourseTaskChanged> invalidCourseTaskInsert = new List<CourseTaskChanged>();
                                foreach (var data in datas)
                                {
                                    var courseTaskInsert = SchoolService.CheckCourseTaskInsertOrChanged($"{grant_type}", scope.ToString(), data, null, null, courseBases, groupListDtos, rooms, null, teachers);
                                    if (courseTaskInsert.invalidCode == 0)
                                    {
                                        string taskCode = $"CourseTask";
                                        string taskId = courseTaskInsert.courseId;
                                        CourseTask courseTask = courseTasks.Where(z => z.id.Equals(taskId) && z.code.Equals(taskCode)).FirstOrDefault();
                                        if (courseTask == null)
                                        {
                                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(taskId, new PartitionKey(taskCode));
                                            if (response.Status == 200)
                                            {
                                                courseTask = JsonDocument.Parse(response.Content).RootElement.ToObject<CourseTask>();

                                            }
                                            else
                                            {
                                                courseTask = new CourseTask
                                                {
                                                    id = taskId,
                                                    code = taskCode,
                                                    pk = "CourseTask",
                                                    ttl = -1,
                                                    courseId = courseTaskInsert.courseId,
                                                    schedules = new List<ScheduleTask> { new ScheduleTask {
                                                        roomId = courseTaskInsert.roomId,
                                                        groupId = courseTaskInsert.groupId,
                                                        type = courseTaskInsert.type,
                                                        teacherId = courseTaskInsert.teacherId,
                                                        notice=courseTaskInsert.notice,
                                                        startTime = courseTaskInsert.startTime,
                                                        times= new List<ScheduleTime>(),
                                                        school=courseTaskInsert.school,
                                                    } }
                                                };
                                            }
                                        }
                                        ScheduleTask scheduleTask = null;
                                        var scheduleTasks = courseTask.schedules.FindAll(z => z.type.Equals(courseTaskInsert.type) && z.groupId.Equals(courseTaskInsert.groupId));
                                        if (scheduleTasks.IsNotEmpty())
                                        {
                                            if (scheduleTasks.Count > 2)
                                            {
                                                courseTask.schedules.RemoveRange(1, scheduleTasks.Count - 1);
                                            }
                                            scheduleTask = scheduleTasks.First();
                                            scheduleTask.roomId = string.IsNullOrWhiteSpace(courseTaskInsert.roomId) ? scheduleTask.roomId : courseTaskInsert.roomId;
                                            scheduleTask.school = school;
                                            scheduleTask.teacherId = courseTaskInsert.teacherId;
                                            scheduleTask.startTime = courseTaskInsert.startTime > 0 ? courseTaskInsert.startTime : scheduleTask.startTime;
                                            scheduleTask.notice = string.IsNullOrWhiteSpace(courseTaskInsert.notice) ? scheduleTask.notice : courseTaskInsert.notice;
                                            scheduleTask.assistants = courseTaskInsert.assistants != null ? courseTaskInsert.assistants : courseTaskInsert.assistants;
                                        }
                                        else
                                        {
                                            scheduleTask = new ScheduleTask()
                                            {
                                                roomId = courseTaskInsert.roomId,
                                                groupId = courseTaskInsert.groupId,
                                                type = courseTaskInsert.type,
                                                teacherId = courseTaskInsert.teacherId,
                                                times = new List<ScheduleTime>(),
                                                school = school,
                                            };
                                            courseTask.schedules.Add(scheduleTask);
                                        }
                                        //修改教师或名单
                                        if (grant_type.ToString().Equals("change-scheduleTask", StringComparison.OrdinalIgnoreCase))
                                        {
                                            if (!string.IsNullOrWhiteSpace(courseTaskInsert.teacherIdChanged))
                                            {
                                                scheduleTask.teacherId = courseTaskInsert.teacherIdChanged;
                                            }
                                            if (!string.IsNullOrWhiteSpace(courseTaskInsert.typeChanged) && !string.IsNullOrWhiteSpace(courseTaskInsert.groupIdChanged))
                                            {
                                                scheduleTask.groupId = courseTaskInsert.groupIdChanged;
                                                scheduleTask.type = courseTaskInsert.typeChanged;
                                            }
                                        }
                                        
                                        //await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(courseTask, new PartitionKey(taskCode));
                                        //删除教师及名单的排课信息
                                        if (grant_type.ToString().Equals("delete-scheduleTask", StringComparison.OrdinalIgnoreCase))
                                        {
                                            courseTask.schedules.Remove(scheduleTask);
                                        }
                                        //如果被删除完了，就删除该条记录。
                                        if (courseTask.schedules.Count <= 0)
                                        {
                                            courseTasks.Remove(courseTask);
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).DeleteItemStreamAsync(courseTask.id, new PartitionKey(courseTask.code));
                                        }
                                        else
                                        {
                                            courseTasks.Add(courseTask);
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(courseTask, new PartitionKey(taskCode));
                                        }

                                    }
                                    else
                                    {
                                        invalidCourseTaskInsert.Add(courseTaskInsert);
                                    }

                                }
                                return Ok(new { invalidCourseTaskInsert, courseTasks });
                            }
                        }
                    //按照模板导入进行数据转换并且进行检查
                    case bool when $"{grant_type}".Equals("import-check") && $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase):
                        {
                            //检查完成，生成一个检查通过的token+检查结果（pass,warn,error）, 在正式导入的时候，只需要检查token是否存在则进行数据保存。 以确保每次被导入的数据都是检查通过的。
                            //并标记相关检查状态对于的具体数值。
                            //数据转换是必须的，可选是否开启数据检查，数据检查包括导入数据自检（逻辑，排他，教室-名单-教师-时间段，重复），导入数据与数据库数据库的比对检查。

                            //课程 批量升学年 学期.
                            if (!request.TryGetProperty("courseCheckImports", out JsonElement _courseCheckImports)) return BadRequest();
                            if (!request.TryGetProperty("periodId", out JsonElement _periodId)) return BadRequest();
                            if (!request.TryGetProperty("semesterId", out JsonElement _semesterId)) return BadRequest();
                            if (!request.TryGetProperty("studyYear", out JsonElement _studyYear) ) return BadRequest();
                            if (!int.TryParse($"{_studyYear}", out int studyYear)) { return BadRequest(); }
                            request.TryGetProperty("majorId", out JsonElement _majorId);

                            School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                            var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                            if (period == null)
                            {
                                return Ok(new { code = 1, msg = "学段不存在！" });
                            }
                            List<CourseCheckImport> courseCheckImports = _courseCheckImports.ToObject<List<CourseCheckImport>>();
                            var courseNoIsNulls = courseCheckImports.Where(x => string.IsNullOrWhiteSpace(x.courseNo));
                            if (courseNoIsNulls!=null  && courseNoIsNulls.Count()>0) {
                                //  return Ok();
                                foreach (var courseNoIsNull in courseNoIsNulls) {
                                    courseNoIsNull.invalidCode=1;
                                }
                                return Ok(new { courseCheckedImports = new HashSet<CourseTask>(), checkedCount=0, invalidCount = courseNoIsNulls.Count(), courseVerifiedImports= new List<CourseCheckImport> (), courseInvalidImports= courseNoIsNulls, checkToken = string.Empty });
                            }
                            //数据检查
                            //1.检查导入的课程编号是否有效
                            StringBuilder sqlNo = new StringBuilder(" select  value c from c ");
                            var courseNoidImports = courseCheckImports.Where(x => string.IsNullOrWhiteSpace(x.courseNo));
                            sqlNo.Append($" where c.no in({string.Join(",", courseCheckImports.Where(x => !string.IsNullOrWhiteSpace(x.courseNo)).Select(z => $"'{z.courseNo}'"))})  and c.period.id='{_periodId}'   ");
                            if (!string.IsNullOrWhiteSpace($"{_majorId}"))
                            {
                                var major = period.majors.Find(z => z.id.Equals($"{_majorId}"));
                                if (major==null)
                                {
                                    return Ok(new { code = 2, msg = "专业不存在！" });
                                }
                                sqlNo.Append($" and c.major.id='{_majorId}'");
                            }
                            List<CourseBase> courseBases = new List<CourseBase>();
                            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                            .GetItemQueryIterator<CourseBase>(queryText: sqlNo.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"CourseBase-{school}") }))
                            {
                                courseBases.Add(item);
                            }
                            HashSet<CourseCheckImport> courseInvalidImports = new HashSet<CourseCheckImport>();
                            HashSet<CourseCheckImport> courseVerifiedImports = new HashSet<CourseCheckImport>();
                            var noInvalidImports = courseCheckImports.Where(z => !courseBases.Select(x => x.no).Contains(z.courseNo));
                            //保留课程名称存在的排课信息
                            if (noInvalidImports != null && noInvalidImports.Any())
                            {
                                foreach (var noInvalidImport in noInvalidImports)
                                {
                                    noInvalidImport.invalidCode =1;
                                    courseInvalidImports.Add(noInvalidImport);
                                }
                                courseCheckImports.RemoveAll(z => noInvalidImports.Contains(z));
                            }

                            //2.检查导入的醍摩豆教师ID是否有效
                            StringBuilder sqlTmdid = new StringBuilder(" select  c.id,c.name ,c.code ,c.picture from c ");
                            //sqlTmdid.Append($" where c.id in({string.Join(",", courseCheckImports.Select(z => $"'{z.tmdid}'"))})    ");
                            List<IdNameCode> teachers = new List<IdNameCode>();
                            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                            .GetItemQueryIterator<IdNameCode>(queryText: sqlTmdid.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school}") }))
                            {
                                teachers.Add(item);
                            }
                            var tmdidInvalidImports = courseCheckImports.ExceptBy(teachers.Select(x => x.id), z => z.tmdid);
                            //保留课程名称存在的及醍摩豆ID有效的排课信息
                            if (tmdidInvalidImports != null && tmdidInvalidImports.Any())
                            {
                                foreach (var tmdidInvalidImport in tmdidInvalidImports)
                                {
                                    tmdidInvalidImport.invalidCode = 2;
                                    courseInvalidImports.Add(tmdidInvalidImport);
                                }
                                courseCheckImports.RemoveAll(z => tmdidInvalidImports.Contains(z));
                            }


                            //3.检查导入的教学班名称是否有效
                            IEnumerable<CourseCheckImport> teachInvalidImports = null;
                            List<GroupList> groupLists = new List<GroupList>();
                            var teachList = courseCheckImports.Where(x => x.type.Equals("teach"));
                            if (teachList.Any() && teachList.Count()>0)
                            {
                                StringBuilder sqlTeach = new StringBuilder(" select value c  from c ");
                                sqlTeach.Append($" where c.name in({string.Join(",", teachList.Select(z => $"'{z.list}'"))})    ");

                                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                                .GetItemQueryIterator<GroupList>(queryText: sqlTeach.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                                {
                                    groupLists.Add(item);
                                }
                                teachInvalidImports = teachList.ExceptBy(groupLists.Select(x => x.name), z => z.list);
                                //保留课程名称存在的及醍摩豆ID有效的排课信息
                                if (teachInvalidImports != null && teachInvalidImports.Any())
                                {
                                    foreach (var teachInvalidImport in teachInvalidImports)
                                    {
                                        teachInvalidImport.invalidCode = 3;
                                        courseInvalidImports.Add(teachInvalidImport);
                                    }
                                    courseCheckImports.RemoveAll(z => teachInvalidImports.Contains(z));
                                }
                            }
                            //4.检查导入的教室编号是否有效
                            //获取填写了教室编号的数据
                            var roomNos = courseCheckImports.Where(z => !string.IsNullOrWhiteSpace(z.roomNo));
                            IEnumerable<CourseCheckImport> roomNoInvalidImports = null;
                            List<Room> rooms = new List<Room>();
                            if (roomNos.Any() && roomNos.Count() > 0)
                            {
                                StringBuilder sqlRoom = new StringBuilder(" select value c  from c ");
                                sqlRoom.Append($" where c.no in({string.Join(",", roomNos.Select(z => $"'{z.roomNo}'"))})    ");

                                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                                .GetItemQueryIterator<Room>(queryText: sqlRoom.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Room-{school}") }))
                                {
                                    rooms.Add(item);
                                }
                                roomNoInvalidImports = courseCheckImports.ExceptBy(rooms.Select(x => x.no), z => z.roomNo);
                                //保留课程名称存在的及醍摩豆ID有效的排课信息
                                if (roomNoInvalidImports != null && roomNoInvalidImports.Any())
                                {
                                    foreach (var roomNoInvalidImport in roomNoInvalidImports)
                                    {
                                        roomNoInvalidImport.invalidCode = 4;
                                        courseInvalidImports.Add(roomNoInvalidImport);
                                    }
                                    courseCheckImports.RemoveAll(z => roomNoInvalidImports.Contains(z));
                                }
                            }
                            //5.检查开学日期，行政班编号是否有效
                            //List<CourseCheckImport> stimeInvalidImports = new List<CourseCheckImport>() ;
                            //List<CourseCheckImport> etimeInvalidImports = new List<CourseCheckImport>();
                            //List<CourseCheckImport> scheduleInvalidImports = new List<CourseCheckImport>();
                            //List<CourseCheckImport> classIdNoInvalidImports = new List<CourseCheckImport>();
                            Dictionary<string, List<Class>> duplicateClasses = new Dictionary<string, List<Class>>();
                            //1  上课时间段的
                            var timeTables = period.timetable.Where(z => z.type.Equals("1")).ToList();
                            HashSet<CourseTask> courseTasks = new HashSet<CourseTask>();
                            int checkedCount = 0;
                            foreach (var item in courseCheckImports)
                            {
                                //DateTimeOffset sdateTime = default;
                                //DateTimeOffset edateTime = default;

                                //5.1.检查开学日期格式是否正确
                                //if (!DateTimeOffset.TryParseExact(item.stime, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out sdateTime))
                                //{
                                //    item.invalidCode = 5;
                                //    courseInvalidImports.Add(item);
                                //    continue;
                                //}
                                //获取当前学年，当前学期，当前导入时间的日期，以及下学期开学时间
                                // (Semester currSemester, int studyYear, DateTimeOffset date, DateTimeOffset nextSemester) info = SchoolService.GetSemester(period, time: item.stime);
                                var currSemester=  period.semesters.Find(v => v.id.Equals($"{_semesterId}"));
                                if (currSemester != null)
                                {
                                    //5.2检查课程结束日期格式是否正确
                                    //if (!string.IsNullOrWhiteSpace(item.etime))
                                    //{
                                    //    if (!DateTimeOffset.TryParseExact(item.etime, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out edateTime))
                                    //    {
                                    //        item.invalidCode = 6;
                                    //        courseInvalidImports.Add(item);
                                    //        continue;
                                    //    }
                                    //}
                                   // else
                                    //{
                                        //未设置课程结束时间，开学前一天
                                       // edateTime = info.nextSemester.AddDays(-1);
                                   //}
                                }
                                else
                                {
                                    //15.根据开学时间无法获取学期信息
                                    item.invalidCode = 15;
                                    courseInvalidImports.Add(item);
                                    continue;
                                }
                                ScheduleTime scheduleTime = null;
                                //5.3检查排课字段格式，数据是否符合要求
                                if (!string.IsNullOrWhiteSpace(item.schedule))
                                {
                                    string[] datas = item.schedule.Split('-');

                                    if (datas.Length >= 3)
                                    {
                                        int timeIndex = -1;
                                        int weekIndex = -1;
                                        string mode = string.Empty;
                                        if (int.TryParse(datas[0], out timeIndex) && timeIndex > 0
                                            && int.TryParse(datas[1], out weekIndex) && weekIndex > 0
                                            && (datas[2].Equals("A", StringComparison.OrdinalIgnoreCase) || datas[2].Equals("D", StringComparison.OrdinalIgnoreCase) || datas[2].Equals("C", StringComparison.OrdinalIgnoreCase)))
                                        {
                                            mode = datas[2];
                                            HashSet<int> weekIndexs = new HashSet<int>();
                                            if (mode.Equals("C"))
                                            {
                                                if (datas.Length == 4)
                                                {
                                                    var customWeeks = datas[3].Split(',');
                                                    bool hasInvalidData = false;
                                                    HashSet<int> weeks = new HashSet<int>();
                                                    foreach (var customWeek in customWeeks)
                                                    {
                                                        if (int.TryParse(customWeek, out int customWeekIndex) && customWeekIndex > 0)
                                                        {
                                                            weeks.Add(customWeekIndex);
                                                        }
                                                        else
                                                        {
                                                            hasInvalidData = true;
                                                            break;
                                                        }
                                                    }
                                                    if (hasInvalidData)
                                                    {
                                                        //C 自定义模式下，配置的上课周是大于等于1的整数
                                                        item.invalidCode = 11;
                                                        courseInvalidImports.Add(item);
                                                        continue;
                                                    }
                                                    else
                                                    {
                                                        weekIndexs = weeks;
                                                    }
                                                }
                                                else
                                                {
                                                    //C 自定义模式下，需要配置对应的上课周
                                                    item.invalidCode = 10;
                                                    courseInvalidImports.Add(item);
                                                    continue;
                                                }
                                            }
                                            scheduleTime = new ScheduleTime();
                                            try
                                            {
                                                var timeTable = timeTables[timeIndex-1];
                                                scheduleTime.id= timeTable.id;
                                            }
                                            catch (Exception ex)
                                            {
                                                //数组越界，表示导入的不存在,没有对应的上课时间段
                                                item.invalidCode = 8;
                                                courseInvalidImports.Add(item);
                                                continue;
                                            }
                                            try
                                            {
                                                var week = weekDays[weekIndex - 1];
                                                scheduleTime.week = week;
                                            }
                                            catch (Exception ex)
                                            {
                                                //数组越界，表示导入的不存在
                                                //上课时间不在星期一至星期日
                                                item.invalidCode = 9;
                                                courseInvalidImports.Add(item);
                                                continue;
                                            }
                                            scheduleTime.mode= mode;
                                            scheduleTime.index = weekIndexs;
                                        }
                                        else
                                        {
                                            //不满足最基本的1-1-A格式,可能是不是数字，或者不是A,D,C模式,
                                            //排课时间格式不满足[1-n]-[1|2|3|4|5|6|7]-[A|D|C]
                                            item.invalidCode = 7;
                                            courseInvalidImports.Add(item);
                                            continue;
                                        }
                                    }
                                    else
                                    {
                                        //不满足最基本的1-1-A格式
                                        //排课时间格式不满足[1-n]-[1|2|3|4|5|6|7]-[A|D|C]
                                        item.invalidCode = 7;
                                        courseInvalidImports.Add(item);
                                        continue;
                                    }
                                }
                                string groupId = string.Empty;
                                //5.4 检查导入的行政班编号是否有效
                                if (item.type.Equals("class"))
                                {
                                    var yearNo = item.list.Split("-");
                                    if (yearNo.Length == 2)
                                    {
                                        StringBuilder sqlYearNo = new StringBuilder(" select value c  from c ");
                                        sqlYearNo.Append($" where c.year ={yearNo[0]} and c.no ='{yearNo[1]}' and c.periodId='{period.id}' ");
                                        List<Class> classes = new List<Class>();
                                        await foreach (var classInfo in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                                        .GetItemQueryIterator<Class>(queryText: sqlYearNo.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Class-{school}") }))
                                        {
                                            classes.Add(classInfo);
                                        }
                                        if (classes.Count > 1)
                                        {
                                            ///班级入学年-编号重复的班级

                                            if (duplicateClasses.ContainsKey(item.list))
                                            {
                                                duplicateClasses[item.list].AddRange(classes);
                                            }
                                            else {
                                                duplicateClasses.TryAdd(item.list, classes);
                                            }
                                            //导入的班级入学年-编号在系统中重复，请检查行政班设置。
                                            item.invalidCode = 13;
                                            courseInvalidImports.Add(item);
                                            continue;
                                        }
                                        else if (classes.Count <= 0)
                                        {
                                            //班级入学年-编号不存在
                                            item.invalidCode = 12;
                                            courseInvalidImports.Add(item);
                                            continue;
                                        }
                                        else
                                        {
                                            Class @class = classes[0];
                                            groupId = @class.id;
                                        }
                                    }
                                    else
                                    {
                                        courseInvalidImports.Add(item);
                                        //导入的班级入学年-编号格式错误
                                        item.invalidCode = 14;
                                        continue;
                                    }
                                }
                                else
                                {
                                    var groupList = groupLists.Find(z => z.name.Equals(item.list));
                                    groupId=groupList?.id;
                                }
                                //检查助教是否存在
                                string[] assistants = new string[] { };
                                if (!string.IsNullOrWhiteSpace(item.assistants))
                                {
                                    assistants = Regex.Split(item.assistants, "\\．|\\.|\\、|\\:|\\：|\\,|\\，|\\；|\\;");
                                    var invalidAssistants = assistants.Except(teachers.Select(x => x.id));
                                    if (invalidAssistants != null && invalidAssistants.Any())
                                    {
                                        item.invalidCode = 21;
                                        item.invalidMsg = $"{string.Join(",", invalidAssistants)}";
                                        courseInvalidImports.Add(item);
                                        continue;
                                    }
                                }

                                Room room = rooms.Find(z => !string.IsNullOrWhiteSpace(item.roomNo) &&  z.no.Equals(item.roomNo));
                                string roomId = room?.id;
                                string teacherId = teachers.Find(z => z.id.Equals(item.tmdid))?.id;
                                CourseBase courseBase = courseBases.Find(z => z.no.Equals(item.courseNo));
                                string taskId = $"{studyYear}-{currSemester.id}-{courseBase.id}";
                                string taskCode = $"CourseTask-{school}";
                                CourseTask courseTask = courseTasks.FirstOrDefault(z => z.id.Equals(taskId) && z.code.Equals(taskCode));
                                if (courseTask == null)
                                {
                                    Azure.Response courseTaskResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync(taskId, new PartitionKey(taskCode));
                                    if (courseTaskResponse.Status == 200)
                                    {
                                        courseTask = JsonDocument.Parse(courseTaskResponse.Content).RootElement.ToObject<CourseTask>();
                                    }
                                }
                                if (courseTask == null)
                                {
                                    courseTask = new CourseTask()
                                    {
                                        id = taskId,
                                        code = taskCode,
                                        //expire = edateTime.ToUnixTimeMilliseconds(),
                                        pk = "CourseTask",
                                        ttl = -1,
                                        courseId = courseBase.id,
                                        year =  studyYear,
                                        semesterId = currSemester.id,
                                        schedules = new List<ScheduleTask>
                                        {
                                           new ScheduleTask()
                                           {
                                                roomId=roomId,
                                                groupId=groupId,
                                                type=item.type,
                                                teacherId=teacherId,
                                                times = scheduleTime!=null ? new List<ScheduleTime> { scheduleTime }: new List<ScheduleTime> {  },
                                                school=school,
                                               assistants=assistants.ToHashSet(),
                                           }
                                        }
                                    };
                                    courseTasks.Add(courseTask);
                                }
                                else
                                {
                                    ScheduleTask scheduleTask = null;
                                    var scheduleTasks = courseTask.schedules.FindAll(z => z.type.Equals(item.type) && z.groupId.Equals(groupId));
                                    if (scheduleTasks.IsNotEmpty())
                                    {
                                        if (scheduleTasks.Count > 2)
                                        {
                                            courseTask.schedules.RemoveRange(1, scheduleTasks.Count - 1);
                                        }
                                        scheduleTask = scheduleTasks.First();
                                        scheduleTask.roomId = string.IsNullOrWhiteSpace(roomId) ? scheduleTask.roomId : roomId;
                                        scheduleTask.school = school;
                                        scheduleTask.teacherId = teacherId;
                                        scheduleTask.assistants = assistants != null ? assistants.ToHashSet() : scheduleTask.assistants;
                                        if (scheduleTime != null)
                                        {
                                            var shtime = scheduleTask.times.Find(z => z.id.Equals(scheduleTime.id) && z.week.Equals(scheduleTime.week) && z.mode.Equals(scheduleTime.mode));
                                            if (shtime == null)
                                            {
                                                scheduleTask.times.Add(scheduleTime);
                                            }
                                            else
                                            {
                                                if (scheduleTime.index.Any())
                                                {
                                                    foreach (var ind in scheduleTime.index)
                                                    {
                                                        shtime.index.Add(ind);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        scheduleTask = new ScheduleTask()
                                        {

                                            roomId = roomId,
                                            groupId = groupId,
                                            type = item.type,
                                            teacherId = teacherId,
                                            times = scheduleTime != null ? new List<ScheduleTime> { scheduleTime } : new List<ScheduleTime> { },
                                            school = school,
                                            assistants= assistants != null ? assistants.ToHashSet() : scheduleTask.assistants
                                        };
                                        courseTask.schedules.Add(scheduleTask);
                                    }
                                    courseTasks.Add(courseTask);
                                }
                                item.invalidCode = 0;
                                courseVerifiedImports.Add(item);
                                checkedCount++;
                            }
                            //生成检查结果token,有效期5分钟

                            if (courseTasks != null && courseTasks.Count > 0)
                            {
                                string checkToken = $"CourseTask:CheckToken:{scope}:{school}:{Guid.NewGuid()}";
                                await _azureRedis.GetRedisClient(8).StringSetAsync(checkToken, courseTasks.ToJsonString(), expiry: new TimeSpan(0, 5, 0));
                                return Ok(new { courseCheckedImports = courseTasks, checkedCount, invalidCount = courseInvalidImports.Count, courseVerifiedImports, courseInvalidImports, checkToken });
                            }
                            else
                            {
                                return Ok(new { courseCheckedImports = courseTasks, checkedCount, invalidCount = courseInvalidImports.Count, courseVerifiedImports, courseInvalidImports, checkToken = string.Empty });
                            }
                        }
                    case bool when $"{grant_type}".Equals("import-task", StringComparison.OrdinalIgnoreCase) && $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase):
                        {
                            request.TryGetProperty("checkToken", out JsonElement _checkToken);
                            if (!string.IsNullOrWhiteSpace($"{_checkToken}") && $"{_checkToken}".StartsWith($"CourseTask:CheckToken:{scope}:{school}:"))
                            {
                                RedisValue value = await _azureRedis.GetRedisClient(8).StringGetAsync($"{_checkToken}");
                                List<CourseTask> courseTasks = value.ToString().ToObject<List<CourseTask>>();
                                if (courseTasks.IsNotEmpty())
                                {
                                    foreach (var task in courseTasks)
                                    {
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(task, new PartitionKey(task.code));
                                    }
                                    return Ok(new { code = 200 });
                                }
                            }
                            return BadRequest();
                        }
                    case bool when $"{grant_type}".Equals("export-task", StringComparison.OrdinalIgnoreCase) && $"{scope}".Equals("school", StringComparison.OrdinalIgnoreCase):
                        {

                            JsonElement _year = default, _semesterId = default, _periodId = default;
                            if (!request.TryGetProperty("periodId", out _periodId)) return BadRequest();
                            if (!request.TryGetProperty("year", out _year))
                            {
                                return BadRequest();
                            }
                            if (!request.TryGetProperty("semesterId", out _semesterId))
                            {
                                return BadRequest();
                            }
                            School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                            var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                            string date = SchoolService.GetOpensByStudyYearAndSemester(period.semesters, int.Parse($"{_year}"), $"{_semesterId}");
                            string sql = $"select value c from c where c.year={_year} and c.semesterId='{_semesterId}'";
                            string code = $"CourseTask-{school}";
                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseTask>(sql, code);
                            List<CourseCheckImport> imports = new List<CourseCheckImport>();
                            if (result.list.IsNotEmpty())
                            {
                                string courseIdSQL = $"select value c from c where c.id in({string.Join(",", result.list.Select(z => $"'{z.courseId}'"))})";
                                List<CourseBase> courseBases = new List<CourseBase>();
                                var resultCourse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseBase>(courseIdSQL, $"CourseBase-{school}");
                                if (resultCourse.list.IsNotEmpty())
                                {
                                    courseBases.AddRange(resultCourse.list);
                                }
                                var classIds = result.list.SelectMany(z => z.schedules).Where(y => y.type.Equals("class") && !string.IsNullOrWhiteSpace(y.groupId)).Select(x => x.groupId);
                                var teachIds = result.list.SelectMany(z => z.schedules).Where(y => y.type.Equals("teach")&& !string.IsNullOrWhiteSpace(y.groupId)).Select(x => x.groupId);
                                var teacherIds = result.list.SelectMany(z => z.schedules).Where(y => !string.IsNullOrWhiteSpace(y.teacherId)).Select(x => x.teacherId);
                                var assistantIds = result.list.SelectMany(z => z.schedules).Where(y => y.assistants!=null && y.assistants.Any()).SelectMany(x => x.assistants);
                                List<Class> classes = new List<Class>();
                                if (classIds!=null  && classIds.Count()>0)
                                {
                                    string classIdSQL = $"select value c from c where c.id in({string.Join(",", classIds.Select(x => $"'{x}'"))})";
                                    var resultClass = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<Class>(classIdSQL, $"Class-{school}");
                                    if (resultClass.list.IsNotEmpty())
                                    {
                                        classes.AddRange(resultClass.list);
                                    }
                                }
                                List<GroupList> groupLists = new List<GroupList>();
                                if (teachIds!=null  && teachIds.Count()>0)
                                {
                                    string teachIdSQL = $"select value c from c where c.id in({string.Join(",", teachIds.Select(x => $"'{x}'"))})";
                                    var resultGroupList = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<GroupList>(teachIdSQL, $"GroupList-{school}");
                                    if (resultGroupList.list.IsNotEmpty())
                                    {
                                        groupLists.AddRange(resultGroupList.list);
                                    }
                                }
                                List<string> tmdids = new List<string>();
                                if (teacherIds!=null  && teacherIds.Count()>0)
                                {
                                    tmdids.AddRange(teacherIds);
                                }
                                if (assistantIds!=null  && assistantIds.Count()>0)
                                {
                                    tmdids.AddRange(assistantIds);
                                }
                                List<Teacher> teachers = new List<Teacher>();
                                if (tmdids.Count>0)
                                {
                                    string tmdidSQL = $"select value c from c where c.id in({string.Join(",", tmdids.Select(x => $"'{x}'"))})";
                                    var resultTmdid = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<Teacher>(tmdidSQL, "Base");
                                    if (resultTmdid.list.IsNotEmpty())
                                    {
                                        teachers.AddRange(resultTmdid.list);
                                    }
                                }
                                foreach (var item in result.list)
                                {
                                    var courseBase = courseBases.Find(z =>!string.IsNullOrWhiteSpace(item.courseId) &&  z.id.Equals(item.courseId));
                                    if (courseBase != null) {
                                        item.schedules.ForEach(z =>
                                        {
                                            //CourseCheckImport courseCheckImport = new CourseCheckImport { name=courseBase?.name, stime=date, grade=courseBase.grade, courseNo=courseBase.no };
                                            CourseCheckImport courseCheckImport = new CourseCheckImport { name=courseBase?.name, grade=courseBase.grade, courseNo=courseBase.no };
                                            if (z.type.Equals("class") &&!string.IsNullOrWhiteSpace(z.groupId))
                                            {
                                                var clazz = classes.Find(x => x.id.Equals(z.groupId));
                                                if (clazz!=null)
                                                {
                                                    courseCheckImport.type=z.type;
                                                    courseCheckImport.list=$"{clazz?.year}-{clazz?.no}";
                                                    courseCheckImport.listName=clazz?.name;
                                                }
                                            }
                                            if (z.type.Equals("teach")&&!string.IsNullOrWhiteSpace(z.groupId))
                                            {
                                                var groupList = groupLists.Find(x => x.id.Equals(z.groupId));
                                                if (groupList!=null)
                                                {
                                                    courseCheckImport.type=z.type;
                                                    courseCheckImport.list=$"{groupList?.name}";
                                                    courseCheckImport.listName=groupList?.name;
                                                }
                                            }
                                            if (!string.IsNullOrWhiteSpace(z.teacherId))
                                            {
                                                var teacher = teachers.Find(x => x.id.Equals(z.teacherId));
                                                if (teacher!=null)
                                                {
                                                    courseCheckImport.tmdid=teacher?.id;
                                                    courseCheckImport.tmdName=teacher?.name;
                                                }
                                            }
                                            if (z.assistants!=null  && z.assistants.Count>0)
                                            {
                                                var teacher_assistants = teachers.FindAll(x => z.assistants.Contains(x.id));
                                                if (teacher_assistants!=null)
                                                {
                                                    courseCheckImport.assistants=string.Join(",", z.assistants);
                                                    courseCheckImport.assistantNames=string.Join(",", teacher_assistants.Select(x => x.name));
                                                }

                                            }
                                            imports.Add(courseCheckImport);
                                        });
                                    }
                                    
                                }
                            }
                            return Ok(new { export = imports, code = 200 });
                        }
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{_option.Location},课程处理异常，{ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return Ok(new { code = 500, msg = ex.Message });
            }
            return Ok();
        }
        //http://localhost:5000/course-base/student
        /*
         *x-auth-authtoken: eyJhbGciOiJodHRwOi8vd3d3LnczLm9yZy8yMDAxLzA0L3htbGRzaWctbW9yZSNobWFjLXNoYTI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJ0ZXN0LnRlYW1tb2RlbC5jbiIsInN1YiI6IjIwMjAwMTAwMSIsImF6cCI6ImhiY24iLCJleHAiOjE2OTE2MzcxOTgsIm5hbWUiOiLljaLkuInor5ciLCJwaWN0dXJlIjoiIiwicm9sZXMiOlsic3R1ZGVudCJdLCJwZXJtaXNzaW9ucyI6bnVsbCwic3RhbmRhcmQiOiIiLCJzY29wZSI6InN0dWRlbnQiLCJhcmVhIjoiNjllM2Q0MTMtNTBhMS00ZjVlLTg0NGEtZTBmN2M5NjIyZWEzIiwid2Vic2l0ZSI6IklFUyJ9.w2ocnKu6RAnvQ6qhH_ZDTO8GSdIVd1ba2Tmd6svv1Ms
         {
            "scope": "school",
            "periodId": "463db08d-cbe7-48a0-a81a-fc39b3c1fep1",
            "grant_type": "attend",
            "year": 2023,
            "semesterId": "08b81e76-e7d2-4001-8b4c-e7c789ef4bs1"
        }
         */
        /// <summary>
        ///学生端课程列表接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "student")]
        [HttpPost("student")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif
        public async Task<IActionResult> Student(JsonElement request) {
            try
            {
                (string userid, _, _, string school) = HttpContext.GetAuthTokenInfo();
                if (!request.TryGetProperty("grant_type", out JsonElement grant_type)) return BadRequest();
                string code = $"CourseTask-{school}";
                var client = _azureCosmos.GetCosmosClient();
                object scope = null;
                HttpContext?.Items.TryGetValue("Scope", out scope);
                int memberType = 2;
                if ($"{scope}".Equals(Constant.ScopeStudent))
                {
                    memberType = 2;
                }
                if ($"{scope}".Equals(Constant.ScopeTmdUser))
                {
                    memberType = 1;
                }
                if ($"{scope}".Equals(Constant.ScopeTeacher))
                {
                    memberType = 1;
                }
               
                switch (true)
                {
                    //学生应参与的课程
                    case bool when $"{grant_type}".Equals("attend", StringComparison.OrdinalIgnoreCase):
                    List<CourseStudentDto> schoolCourses = new List<CourseStudentDto>();
                    List<CourseStudentDto> teahcerCourses = new List<CourseStudentDto>();
                    List<IdNameCode> teachers = new List<IdNameCode>();
                    List<IdName> rooms = new List<IdName>();
                    List<GroupListGrp> groups = await GroupListService.GetMemberInGroupList(_coreAPIHttpService, client, _dingDing, userid, memberType, school, new List<string> { "class", "teach" });
                    if (groups.IsNotEmpty())
                    {
                        List<string> groupIds = groups.Select(x => x.id).ToList();
                        HashSet<string> roomIds = new HashSet<string>();
                        HashSet<string> teacherIds = new HashSet<string>();
                        string sql = $"SELECT distinct value c FROM c  join b in c.schedules where c.pk='CourseTask' and b.groupId in({string.Join(",", groups.Select(x => $"'{x.id}'"))}) ";
                        List<KeyValuePair<string, CourseTask>> schoolGroupTask = new List<KeyValuePair<string, CourseTask>>();
                        List<KeyValuePair<string, CourseTask>> privateGroupTask = new List<KeyValuePair<string, CourseTask>>();
                           
                        if (!string.IsNullOrWhiteSpace(school))
                        {
                            School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                            JsonElement _year = default, _semesterId = default, _periodId = default;
                            if (!request.TryGetProperty("periodId", out _periodId)) return BadRequest();
                            if (!request.TryGetProperty("year", out _year))
                            {
                                return BadRequest();
                            }
                            if (!request.TryGetProperty("semesterId", out _semesterId))
                            {
                                return BadRequest();
                            }
                            var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                            //string date = SchoolService.GetOpensByStudyYearAndSemester(period.semesters, int.Parse($"{_year}"), $"{_semesterId}");
                            sql = $"{sql} and  c.year={_year} and c.semesterId='{_semesterId}'";
                            HashSet<string> courseIds = new HashSet<string>();
                            var resultSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseTask>(sql, $"CourseTask-{school}");
                            if (resultSchool.list.IsNotEmpty())
                            {
                                resultSchool.list.ForEach(x =>
                                {
                                    var schedulesGroup = x.schedules.Where(z => !string.IsNullOrWhiteSpace(z.groupId)   &&groupIds.Contains(z.groupId));
                                    if (schedulesGroup.Any())
                                    {
                                        courseIds.Add(x.courseId);
                                        CourseTask courseTask = x.ToJsonString().ToObject<CourseTask>();
                                        courseTask.schedules=schedulesGroup.ToList();
                                        courseTask.schedules.ForEach(z => {
                                            if (!string.IsNullOrWhiteSpace(z.roomId)) {
                                                roomIds.Add(z.roomId);
                                            }
                                            if (!string.IsNullOrWhiteSpace(z.teacherId))
                                            {
                                                teacherIds.Add(z.teacherId);
                                            }
                                            if (z.assistants!=null) {
                                                foreach (var assistant in z.assistants) {
                                                    teacherIds.Add(assistant);
                                                }
                                            }
                                        });
                                        schoolGroupTask.Add(new KeyValuePair<string, CourseTask>(x.courseId, courseTask));
                                    }
                                });
                            }
                            if (courseIds.Any())
                            {
                                string sqlCourse = $"select value c from c where c.id in ({string.Join(",", courseIds.Select(b => $"'{b}'"))})";
                                var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseBase>(sqlCourse, $"CourseBase-{school}");
                                if (result.list.IsNotEmpty())
                                {
                                    foreach (var item in result.list)
                                    {
                                        List<CourseTaskDto> courseTaskDtos = new List<CourseTaskDto>();
                                        var group = schoolGroupTask.Where(x => x.Key.Equals(item.id)).Select(z => z.Value);
                                        if (group.Any())
                                        {
                                            schoolCourses.Add(new CourseStudentDto { courseBase=item, courseTasks=group.ToList() });
                                        }

                                    }
                                }
                            }
                        }
                        string sqlprivate = $"SELECT distinct value c FROM c  join b in c.schedules where c.pk='CourseTask' and b.groupId in({string.Join(",", groups.Select(x => $"'{x.id}'"))}) ";
                        var resultTeacher = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<CourseTask>(sqlprivate, $"CourseTask");
                        if (resultTeacher.list.IsNotEmpty())
                        {
                            HashSet<string> courseIds = new HashSet<string>();
                            resultTeacher.list.ForEach(x =>
                            {
                                var schedulesGroup = x.schedules.Where(z => !string.IsNullOrWhiteSpace(z.groupId)  &&groupIds.Contains(z.groupId));
                                if (schedulesGroup.Any())
                                {
                                    courseIds.Add(x.courseId);
                                    CourseTask courseTask = x.ToJsonString().ToObject<CourseTask>();
                                    courseTask.schedules=schedulesGroup.ToList();
                                    courseTask.schedules.ForEach(z => {
                                        if (!string.IsNullOrWhiteSpace(z.teacherId))
                                        {
                                            teacherIds.Add(z.teacherId);
                                        }
                                        if (z.assistants!=null)
                                        {
                                            foreach (var assistant in z.assistants)
                                            {
                                                teacherIds.Add(assistant);
                                            }
                                        }
                                    });
                                    privateGroupTask.Add(new KeyValuePair<string, CourseTask>(x.courseId, courseTask));
                                }

                            });
                            if (courseIds.Any())
                            {
                                string sqlCourse = $"select value c from c where c.id in ({string.Join(",", courseIds.Select(b => $"'{b}'"))})";
                                var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<CourseBase>(sqlCourse, $"CourseBase");
                                if (result.list.IsNotEmpty())
                                {
                                    foreach (var item in result.list)

                                    {
                                        List<CourseTaskDto> courseTaskDtos = new List<CourseTaskDto>();
                                        var group = privateGroupTask.Where(x => x.Key.Equals(item.id)).Select(z => z.Value);
                                        if (group.Any())
                                        {
                                            teahcerCourses.Add(new CourseStudentDto { courseBase=item, courseTasks=group.ToList() });
                                        }
                                    }
                                }
                            }
                        }
                        if (roomIds.Any()) {
                                string sqlRoom = $"select value c from c where c.id in ({string.Join(",",roomIds.Select(z=>$"'{z}'"))})";
                                var result=  await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<IdName>(sqlRoom, $"Room-{school}");
                                if (result.list.IsNotEmpty())
                                {
                                    rooms.AddRange(result.list);
                                }
                        }
                        if (teacherIds.Any())
                        {
                            string sqlTeacher = $"select value c from c where c.id in ({string.Join(",", teacherIds.Select(z => $"'{z}'"))})";
                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<IdNameCode>(sqlTeacher, $"Base");
                            if (result.list.IsNotEmpty())
                            {
                                teachers.AddRange(result.list);
                            }
                        }
                    }
                    return Ok(new { teahcerCourses, schoolCourses, rooms,teachers,groups= groups.Select(z=>new { z.id,z.name , z.type,z.no ,z.school,z.scope,z.periodId,z.year,z.grades})});
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{_option.Location},course-base\teacher{ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest(new { ex.Message });
            }
            return Ok();
        }
        //

        /*
         *x-auth-authtoken: eyJhbGciOiJodHRwOi8vd3d3LnczLm9yZy8yMDAxLzA0L3htbGRzaWctbW9yZSNobWFjLXNoYTI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJ0ZXN0LnRlYW1tb2RlbC5jbiIsInN1YiI6IjE1OTUzMjEzNTQiLCJhenAiOiJoYmNuIiwiZXhwIjoxNjgyNjc0MDEwLCJuYW1lIjoi572X6ICB5biIIiwicGljdHVyZSI6Imh0dHBzOi8vY29yZXN0b3JhZ2VzZXJ2aWNlLmJsb2IuY29yZS5jaGluYWNsb3VkYXBpLmNuL2FjY291bnQvYXZhdGFyLzE1OTUzMjEzNTQiLCJyb2xlcyI6WyJ0ZWFjaGVyIiwiYWRtaW4iLCJhcmVhIl0sInBlcm1pc3Npb25zIjpbXSwic3RhbmRhcmQiOiJzdGFuZGFyZDEiLCJzY29wZSI6InRlYWNoZXIiLCJhcmVhIjoiNjllM2Q0MTMtNTBhMS00ZjVlLTg0NGEtZTBmN2M5NjIyZWEzIiwid2Vic2l0ZSI6IklFUyJ9.5-5M9FYQspxvBJy6B5ARwC5mS6lbb5WEeDPXjfo29Hk
         {
    "scope": "school",
    "periodId": "463db08d-cbe7-48a0-a81a-fc39b3c1fep1",
    "grant_type": "teach",
    "year": 2023,
    "semesterId": "08b81e76-e7d2-4001-8b4c-e7c789ef4bs1"
}
         */
        //http://localhost:5000/course-base/student
        /// <summary>
        /// 教师任教的课程
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "teacher,admin")]
        [HttpPost("teacher")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif
        public async Task<IActionResult> Teacher(JsonElement request)
        {

            try
            {
                (string tmdid, _, _, string school) = HttpContext.GetAuthTokenInfo();
                if (!request.TryGetProperty("grant_type", out JsonElement grant_type)) return BadRequest();
                string code = $"CourseTask-{school}";
                var client = _azureCosmos.GetCosmosClient();
                switch (true)
                {
                    //任教学校课程和个人课程
                    case bool when $"{grant_type}".Equals("teach", StringComparison.OrdinalIgnoreCase):
                        string sql  = $"SELECT distinct value c FROM c  join b in c.schedules where c.pk='CourseTask' and (ARRAY_CONTAINS(b.assistants,'{tmdid}')or  b.teacherId  ='{tmdid}' )";
                        List<KeyValuePair<string,CourseTask >> schoolTeacherTask = new List<KeyValuePair<string, CourseTask>>();
                        List<KeyValuePair<string,CourseTask >> schoolAssistantTask = new  List<KeyValuePair<string,CourseTask >>();

                        List<KeyValuePair<string,CourseTask >> privateTeacherTask = new  List<KeyValuePair<string,CourseTask >>();
                        List<KeyValuePair<string,CourseTask >> privateAssistantTask = new  List<KeyValuePair<string,CourseTask >>();
                        List<CourseDto> schoolCourses = new List<CourseDto>();
                        List<CourseDto> teahcerCourses = new List<CourseDto>();
                        List<string> groupIds = new List<string>();
                        if (!string.IsNullOrWhiteSpace(school)) 
                        {
                            School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                            JsonElement _year = default, _semesterId = default, _periodId = default;
                            if (!request.TryGetProperty("periodId", out _periodId)) return BadRequest();
                            if (!request.TryGetProperty("year", out _year))
                            {
                                return BadRequest();
                            }
                            if (!request.TryGetProperty("semesterId", out _semesterId))
                            {
                                return BadRequest();
                            }
                            var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                            //string date = SchoolService.GetOpensByStudyYearAndSemester(period.semesters, int.Parse($"{_year}"), $"{_semesterId}");
                            sql = $"{sql} and  c.year={_year} and c.semesterId='{_semesterId}'";
                            HashSet<string> courseIds = new HashSet<string>();
                            var resultSchool= await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseTask>(sql, $"CourseTask-{school}");
                            if (resultSchool.list.IsNotEmpty()) {
                                resultSchool.list.ForEach(x => {
                                   var schedulesTeacher =   x.schedules.Where(z =>!string.IsNullOrWhiteSpace(z.teacherId)   && z.teacherId.Equals(tmdid));
                                    if (schedulesTeacher.Any()) 
                                    {
                                        courseIds.Add(x.courseId);
                                        CourseTask courseTask = x.ToJsonString().ToObject<CourseTask>();
                                        courseTask.schedules=schedulesTeacher.ToList();
                                        schoolTeacherTask.Add(new KeyValuePair<string,CourseTask  >(x.courseId, courseTask));
                                        //groupIds.AddRange(schedulesTeacher.Where(z => !string.IsNullOrWhiteSpace(z.groupId)).Select(x => x.groupId));
                                    }
                                    var schedulesAssistant = x.schedules.Where(z => z.assistants.Contains(tmdid) );
                                    if (schedulesAssistant.Any())
                                    {
                                        courseIds.Add(x.courseId);
                                        CourseTask courseTask = x.ToJsonString().ToObject<CourseTask>();
                                        courseTask.schedules=schedulesAssistant.ToList();
                                        schoolAssistantTask.Add(new KeyValuePair<string, CourseTask>(x.courseId, courseTask));
                                        //groupIds.AddRange(schedulesAssistant.Where(z => !string.IsNullOrWhiteSpace(z.groupId)).Select(x => x.groupId));
                                    }
                                });
                            }
                            if (courseIds.Any()) {
                                string sqlCourse = $"select value c from c where c.id in ({string.Join(",",courseIds.Select(b=>$"'{b}'"))})";
                                var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseBase>(sqlCourse, $"CourseBase-{school}");
                                if (result.list.IsNotEmpty()) 
                                {
                                    foreach (var item in result.list) 
                                    {
                                        List<CourseTaskDto> courseTaskDtos = new List<CourseTaskDto>();
                                        var teacher = schoolTeacherTask.Where(x => x.Key.Equals(item.id)).Select(z => new CourseTaskDto { courseTask=z.Value, type="teacher" });
                                        if (teacher.Any()) {
                                            courseTaskDtos.AddRange(teacher.ToList());
                                        }
                                        var assistant= schoolAssistantTask.Where(x => x.Key.Equals(item.id)).Select(z => new CourseTaskDto {  courseTask=z.Value, type="assistant" });
                                        if (assistant.Any()) {
                                            courseTaskDtos.AddRange(assistant.ToList());
                                        }
                                        schoolCourses.Add(new CourseDto { courseBase=item, courseTasks=courseTaskDtos });
                                    }
                                }
                            }
                        }
                      
                        {
                            HashSet<string> courseIds = new HashSet<string>();
                            string sqlCoursePrivate = $"select value c.id from c where  c.creatorId='{tmdid}'";
                            var resultCourseBasePrivate = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<string>(sqlCoursePrivate, $"CourseBase");
                            if (resultCourseBasePrivate.list.IsNotEmpty())
                            {
                                courseIds=new HashSet<string>(resultCourseBasePrivate.list);
                            }
                            string sqlprivate = $"SELECT distinct value c FROM c  join b in c.schedules where c.pk='CourseTask' and (ARRAY_CONTAINS(b.assistants,'{tmdid}')or  b.teacherId  ='{tmdid}' )";
                            var resultTeacher = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<CourseTask>(sqlprivate, $"CourseTask");
                            if (resultTeacher.list.IsNotEmpty())
                            {

                                resultTeacher.list.ForEach(x => {
                                    var schedulesTeacher = x.schedules.Where(z => !string.IsNullOrWhiteSpace(z.teacherId)  &&  z.teacherId.Equals(tmdid));
                                    if (schedulesTeacher.Any())
                                    {
                                        courseIds.Add(x.courseId);
                                        CourseTask courseTask = x.ToJsonString().ToObject<CourseTask>();
                                        courseTask.schedules=schedulesTeacher.ToList();
                                        privateTeacherTask.Add(new KeyValuePair<string, CourseTask>(x.courseId, courseTask));
                                        groupIds.AddRange(schedulesTeacher.Where(z => !string.IsNullOrWhiteSpace(z.groupId)).Select(x => x.groupId));
                                    }
                                    var schedulesAssistant = x.schedules.Where(z => z.assistants.Contains(tmdid));
                                    if (schedulesAssistant.Any())
                                    {
                                        courseIds.Add(x.courseId);
                                        CourseTask courseTask = x.ToJsonString().ToObject<CourseTask>();
                                        courseTask.schedules=schedulesAssistant.ToList();
                                        privateAssistantTask.Add(new KeyValuePair<string, CourseTask>(x.courseId, courseTask));
                                        groupIds.AddRange(schedulesAssistant.Where(z=>!string.IsNullOrWhiteSpace(z.groupId)).Select(x => x.groupId));
                                    }
                                });
                               
                            }
                            if (courseIds.Any())
                            {
                                string sqlCourse = $"select distinct value c from c where c.code='CourseBase' and  ( c.creatorId='{tmdid}' or  c.id in ({string.Join(",", courseIds.Select(b => $"'{b}'"))}))";
                                var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<CourseBase>(sqlCourse, $"CourseBase");
                                if (result.list.IsNotEmpty())
                                {
                                    foreach (var item in result.list)

                                    {
                                        List<CourseTaskDto> courseTaskDtos = new List<CourseTaskDto>();
                                        var teacher = privateTeacherTask.Where(x => x.Key.Equals(item.id)).Select(z => new CourseTaskDto { courseTask=z.Value, type="teacher" });
                                        if (teacher.Any())
                                        {
                                            courseTaskDtos.AddRange(teacher.ToList());
                                        }
                                        var assistant = privateAssistantTask.Where(x => x.Key.Equals(item.id)).Select(z => new CourseTaskDto { courseTask=z.Value, type="assistant" });
                                        if (assistant.Any())
                                        {
                                            courseTaskDtos.AddRange(assistant.ToList());
                                        }
                                        teahcerCourses.Add(new CourseDto { courseBase=item, courseTasks=courseTaskDtos });
                                    }
                                }
                            }
                            //个人，
                            //学校，
                            //助教，学校。
                            //助教，个人。
                            var groupIdsRel= groupIds.GroupBy(z => z).Select(z => new { groupId = z.Key, count = z.ToList().Count() });
                            return Ok(new { teahcerCourses, schoolCourses, groupIdsRel });
                        }
                }
            }
            catch (Exception ex)
            {
               await _dingDing.SendBotMsg($"{_option.Location},course-base\teacher{ex.Message}\n{ex.StackTrace}",GroupNames.成都开发測試群組);
                return BadRequest(new { ex.Message});
            }
            return Ok();
        }



        /// <summary>
        ///
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]

        [HttpPost("data-migration-to-class")]
        public async Task<IActionResult> DataMigrationToClass(JsonElement request)
        {
            try
            {
                List<Course> schoolCourses = new List<Course>();
                HashSet<string> schoolIds = new HashSet<string>();
                string sql = "select value c from c where c.pk='Course' ";
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetItemQueryIterator<Course>(queryText: sql))
                {
                    schoolCourses.Add(item);

                    if (!string.IsNullOrWhiteSpace(item.school))
                    {
                        if (item.school.Equals("ydzt") ||item.school.Equals("xcfx") ||item.school.Equals("hlgj") ||item.school.Equals("hbcn") ||item.school.Equals("kjyxx") ||item.school.Equals("bjgsex") || item.school.Equals("cdxxps") ||item.school.Equals("pclxxx"))
                        {

                        }
                        else
                        {
                            schoolCourses.Add(item);
                            schoolIds.Add(item.school);
                        }
                    }
                    //if (!string.IsNullOrWhiteSpace(item.school))
                    //{
                    //    schoolIds.Add(item.school);

                    //}
                }
                List<School> schools = new List<School>();
                if (schoolIds.Count>0)
                {
                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<School>($"select value c from c where c.id  in ({string.Join(",", schoolIds.Select(z => $"'{z}'"))})", "Base");
                    if (result.list.IsNotEmpty())
                    {
                        schools.AddRange(result.list);
                    }
                }
                List<CourseDto> schoolCourseDtos = new List<CourseDto>();
                int coureseIndex = 1;
                foreach (var course in schoolCourses)
                {
                    var school = schools.Find(z => z.id.Equals(course.school));
                    if (school==null) { continue; }
                    var period = school.period.Find(z => z.id.Equals(course.period?.id));
                    if (period==null)
                    {
                        continue;
                    }
                    //当前学年
                    var semester = SchoolService.GetSemester(period, DateTimeOffset.Now.ToUnixTimeMilliseconds());
                 
                    Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync(course.id, new PartitionKey($"CourseBase-{school.id}"));
                    if (response.Status==200) {
                        CourseBase courseBase = JsonDocument.Parse(response.Content).RootElement.ToObject<CourseBase>();
                        if (courseBase!= null) {
                            if (string.IsNullOrWhiteSpace(courseBase.no)) 
                            {
                                //生成新的课程编号
                                string sqlNo = $"select  value c.no from c where c.period.id='{courseBase.period.id}'  ";
                                var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<string>(sqlNo, courseBase.code);
                                if (result.list.IsNotEmpty())
                                {
                                    if (period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))>0)
                                    {
                                        int index = period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id)) +1;
                                        var nos = result.list.FindAll(x => !string.IsNullOrWhiteSpace(x) &&  x.StartsWith($"{index}")).ToHashSet<string>();
                                        if (nos != null)
                                        {
                                            string couresNo = string.Empty;
                                            List<string> order = nos.Where(y => !string.IsNullOrEmpty(y) && Regex.IsMatch(y, @"^\d*$")).OrderBy(x => int.Parse(x)).ToList();
                                            if (!order.Contains($"{index}00"))
                                            {
                                                order.Insert(0, $"{index}00");
                                            }
                                            if (order != null)
                                            {
                                                if (!order.Contains($"{index}00"))
                                                {
                                                    order.Insert(0, $"{index}00");
                                                }
                                            }
                                            else { order = new List<string>() { $"{index}00" }; }
                                            for (int i = 0; i < order.Count; i++)
                                            {
                                                couresNo = $"{int.Parse(order[i]) + 1}";
                                                int no = i + 1;
                                                if (no <= order.Count - 1)
                                                {
                                                    if (!couresNo.Equals(order[no]))
                                                    {
                                                        break;
                                                    }
                                                }
                                            }
                                            if (string.IsNullOrWhiteSpace(couresNo))
                                            {
                                                couresNo=$"{index}99";
                                            }
                                            courseBase.no=couresNo;
                                        }
                                        else
                                        {
                                            courseBase.no= $"{index}01";
                                        }
                                    }
                                    else
                                    {
                                        courseBase.no=$"{coureseIndex}99";
                                    }
                                }
                                else
                                {
                                    if (period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))>0)
                                    {
                                        courseBase.no= $"{(period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))+1)}01";
                                    }
                                    else
                                    {
                                        courseBase.no=$"{coureseIndex}99";
                                    }
                                }
                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(courseBase, new PartitionKey(courseBase.code));
                            }
                            for (int grade = 0; grade<period.grades.Count; grade++) {
                                if (courseBase.grade==grade) {
                                    continue; 
                                }
                                coureseIndex=+1;
                                string sqlBaseData = $"select value c from c where c.name ='{course.name}' and c.grade={grade} and c.period.id='{period.id}'  and c.subject.id='{course.subject.id}'";
                                var resultBaseData = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseBase>(sqlBaseData, $"CourseBase-{school.id}");
                                if (!resultBaseData.list.IsNotEmpty()) {
                                    CourseBase courseBaseNew = new CourseBase()
                                    {
                                        id= Guid.NewGuid().ToString(),
                                        code=$"CourseBase-{school.id}",
                                        pk="CourseBase",
                                        ttl=-1,
                                        name=course.name,
                                        subject= new IdName { id=course.subject?.id, name=course.subject?.name },
                                        period= new IdName { id= course.period?.id, name =course.period?.name },
                                        school=school.id,
                                        scope="school",
                                        creatorId=course.creatorId,
                                        desc=course.desc,
                                        status=1,
                                        grade=grade,
                                    };
                                    //生成新的课程编号
                                    string sqlNo = $"select  value c.no from c where c.period.id='{courseBase.period.id}'  ";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<string>(sqlNo, courseBase.code);
                                    if (result.list.IsNotEmpty())
                                    {
                                        if (period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))>0)
                                        {
                                            int index = period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id)) +1;
                                            var nos = result.list.FindAll(x => !string.IsNullOrWhiteSpace(x) &&  x.StartsWith($"{index}")).ToHashSet<string>();
                                            if (nos != null)
                                            {
                                                string couresNo = string.Empty;
                                                List<string> order = nos.Where(y => !string.IsNullOrEmpty(y) && Regex.IsMatch(y, @"^\d*$")).OrderBy(x => int.Parse(x)).ToList();
                                                if (!order.Contains($"{index}00"))
                                                {
                                                    order.Insert(0, $"{index}00");
                                                }
                                                if (order != null)
                                                {
                                                    if (!order.Contains($"{index}00"))
                                                    {
                                                        order.Insert(0, $"{index}00");
                                                    }
                                                }
                                                else { order = new List<string>() { $"{index}00" }; }
                                                for (int i = 0; i < order.Count; i++)
                                                {
                                                    couresNo = $"{int.Parse(order[i]) + 1}";
                                                    int no = i + 1;
                                                    if (no <= order.Count - 1)
                                                    {
                                                        if (!couresNo.Equals(order[no]))
                                                        {
                                                            break;
                                                        }
                                                    }
                                                }
                                                if (string.IsNullOrWhiteSpace(couresNo))
                                                {
                                                    couresNo=$"{index}99";
                                                }
                                                courseBase.no=couresNo;
                                            }
                                            else
                                            {
                                                courseBase.no= $"{index}01";
                                            }
                                        }
                                        else
                                        {
                                            courseBase.no=$"{coureseIndex}99";
                                        }
                                    }
                                    else
                                    {
                                        if (period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))>0)
                                        {
                                            courseBase.no= $"{(period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))+1)}01";
                                        }
                                        else
                                        {
                                            courseBase.no=$"{coureseIndex}99";
                                        }
                                    }
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(courseBaseNew, new PartitionKey(courseBaseNew.code));
                                }
                            }
                        }
                    }
                    List<ScheduleTask> schedules = new List<ScheduleTask>();
                    foreach (var schedule in course.schedule)
                    {
                        ScheduleTask scheduleSave = null; 
                        int grade = -1;
                        if (!string.IsNullOrWhiteSpace(schedule.teacherId) && !string.IsNullOrWhiteSpace(schedule.classId))
                        {
                            scheduleSave =new ScheduleTask() { type="class", groupId=schedule.classId, teacherId=schedule.teacherId, roomId= schedule.room, school=school.id };
                            try
                            {
                                Class clazz = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<Class>(schedule.classId, new PartitionKey($"Class-{school.id}"));
                                if (semester.studyYear- clazz.year>=period.grades.Count)
                                {
                                    grade=-1;
                                }
                                else {
                                    var gradeData = SchoolService.GetGrades(school, period.id, new List<int>() { clazz.year }, DateTimeOffset.Now.ToUnixTimeMilliseconds());
                                    if (gradeData.grades.Any() && gradeData.grades.Count>0)
                                    {
                                        int.TryParse(gradeData.grades.First(), out grade);
                                    }
                                }
                               
                            }
                            catch { }
                        }
                        if (!string.IsNullOrWhiteSpace(schedule.teacherId) && !string.IsNullOrWhiteSpace(schedule.stulist))
                        {
                            scheduleSave = new ScheduleTask() { type="teach", groupId=schedule.stulist, teacherId=schedule.teacherId, roomId= schedule.room, school=school.id };
                            if (grade==-1)
                            {
                                _coreAPIHttpService.check=false;
                                var groups = await GroupListService.GetMemberByListids(_coreAPIHttpService, _azureCosmos.GetCosmosClient(), _dingDing, new List<string> { schedule.stulist }, school.id);
                                if (groups.rmembers.IsNotEmpty())
                                {
                                    var a = groups.rmembers.Where(z => z.type==2  && z.year>0).GroupBy(z => z.year).Select(z => new { key = z.Key, list = z.ToList() }).OrderByDescending(y => y.list.Count).FirstOrDefault();
                                    if (a!=null)
                                    {
                                        if (semester.studyYear- a.key>=period.grades.Count)
                                        {
                                            grade=-1;
                                        }
                                        else {
                                            var gradeData = SchoolService.GetGrades(school, period.id, new List<int>() { a.key }, DateTimeOffset.Now.ToUnixTimeMilliseconds());

                                            if (gradeData.grades.Any() && gradeData.grades.Count>0)
                                            {
                                                int.TryParse(gradeData.grades.First(), out grade);
                                            }
                                        }
                                           
                                    }
                                }
                            }
                        }
                        if (grade>-1) {
                            string sqlCourse = $"select value c from c where c.name ='{course.name}' and c.grade={grade} and c.period.id='{period.id}' and c.subject.id='{course.subject?.id}' ";
                            var resultCourseBase= await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<CourseBase>(sqlCourse,$"CourseBase-{school.id}");
                            foreach (var item in resultCourseBase.list) {
                                if (semester.currSemester!=null)
                                {
                                    string id = $"{semester.studyYear}-{semester.currSemester.id}-{item.id}";
                                    string code = $"CourseTask-{school.id}";
                                    Azure.Response responseTask=  await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync(id, new PartitionKey(code));
                                    CourseTask courseTask = null;
                                    if (responseTask.Status==200)
                                    {
                                        courseTask = JsonDocument.Parse(responseTask.Content).RootElement.ToObject<CourseTask>();
                                        var scheduleExsit = courseTask.schedules.Find(z => z.groupId.Equals(scheduleSave.groupId));
                                        if (scheduleExsit==null)
                                        {
                                            courseTask.schedules.Add(scheduleSave);
                                        }
                                        else {
                                            scheduleExsit.teacherId=scheduleSave.teacherId;
                                        }
                                    }
                                    else {
                                        courseTask = new CourseTask
                                        {
                                            id = id,
                                            code = code,
                                            pk="CourseTask",
                                            ttl=-1,
                                            courseId=item.id,
                                            year= semester.studyYear,
                                            expire= semester.nextSemester.AddDays(-1).ToUnixTimeMilliseconds(),
                                            semesterId=semester.currSemester.id,
                                            schedules=new List<ScheduleTask>() { scheduleSave }
                                        };
                                    }
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(courseTask, new PartitionKey(code));
                                }
                            }
                        }
                    }

                }

              
                return Ok(new { schoolCourseDtos });
            }
            catch (Exception ex) { return Ok($"{ex.Message},{ex.StackTrace}"); }

            return Ok();
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
     
        [HttpPost("data-migration")]
        public async Task<IActionResult> DataMigration(JsonElement request) {
            try {
                List<Course> teacherCourses = new List<Course>();
                List<Course> schoolCourses = new List<Course>();
                HashSet<string> schoolIds = new HashSet<string>();
                string sql = "select value c from c where c.pk='Course' ";
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetItemQueryIterator<Course>(queryText: sql))
                {
                   
                    if (!string.IsNullOrWhiteSpace(item.school))
                    {
                        schoolCourses.Add(item);
                        schoolIds.Add(item.school);
                        if (item.school.Equals("ydzt") ||item.school.Equals("xcfx") ||item.school.Equals("hlgj") ||item.school.Equals("hbcn") ||item.school.Equals("kjyxx") ||item.school.Equals("bjgsex") || item.school.Equals("cdxxps") ||item.school.Equals("pclxxx"))
                        {

                        }
                        else
                        {

                        }
                    }
                }
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetItemQueryIterator<Course>(sql))
                {
                    teacherCourses.Add(item);
                }



                List<School> schools = new List<School>();
                if (schoolIds.Count>0)
                {
                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<School>($"select value c from c where c.id  in ({string.Join(",", schoolIds.Select(z => $"'{z}'"))})", "Base");
                    if (result.list.IsNotEmpty())
                    {
                        schools.AddRange(result.list);
                    }
                }
                List<CourseDto> schoolCourseDtos = new List<CourseDto>();
                int coureseIndex = 1;
                foreach (var course in schoolCourses)
                {
                    var school = schools.Find(z => z.id.Equals(course.school));
                    if (school==null) { continue; }
                    var period = school.period.Find(z => z.id.Equals(course.period?.id));
                    if(period==null)
                    {
                        continue;
                    }
                    var semester = SchoolService.GetSemester(period,time: "2023-07-01");
                    CourseBase courseBase = null;
                    Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync(course.id, new PartitionKey($"CourseBase-{school.id}"));
                    if (response.Status==200)
                    {
                        courseBase = JsonDocument.Parse(response.Content).RootElement.ToObject<CourseBase>();
                        if (courseBase!= null)
                        {
                            //生成新的课程编号
                            string sqlNo = $"select  value c.no from c where c.period.id='{courseBase.period.id}'  ";
                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<string>(sqlNo, courseBase.code);
                            if (result.list.IsNotEmpty())
                            {
                                if (period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))>0)
                                {
                                    int index = period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id)) +1;
                                    var nos = result.list.FindAll(x => !string.IsNullOrWhiteSpace(x) &&  x.StartsWith($"{index}")).ToHashSet<string>();
                                    if (nos != null)
                                    {
                                        string couresNo = string.Empty;
                                        List<string> order = nos.Where(y => !string.IsNullOrEmpty(y) && Regex.IsMatch(y, @"^\d*$")).OrderBy(x => int.Parse(x)).ToList();
                                        if (!order.Contains($"{index}00"))
                                        {
                                            order.Insert(0, $"{index}00");
                                        }
                                        if (order != null)
                                        {
                                            if (!order.Contains($"{index}00"))
                                            {
                                                order.Insert(0, $"{index}00");
                                            }
                                        }
                                        else { order = new List<string>() { $"{index}00" }; }
                                        for (int i = 0; i < order.Count; i++)
                                        {
                                            couresNo = $"{int.Parse(order[i]) + 1}";
                                            int no = i + 1;
                                            if (no <= order.Count - 1)
                                            {
                                                if (!couresNo.Equals(order[no]))
                                                {
                                                    break;
                                                }
                                            }
                                        }
                                        if (string.IsNullOrWhiteSpace(couresNo))
                                        {
                                            couresNo=$"{index}99";
                                        }
                                        courseBase.no=couresNo;
                                    }
                                    else
                                    {
                                        courseBase.no= $"{index}01";
                                    }
                                }
                                else {
                                    courseBase.no=$"{coureseIndex}99";
                                }
                            }
                            else
                            {
                                if (period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))>0)
                                {
                                    courseBase.no= $"{(period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))+1)}01";
                                }
                                else {
                                    courseBase.no=$"{coureseIndex}99";
                                }
                            }
                        }
                    }
                    else {
                         courseBase = new CourseBase()
                        {
                            id= course.id,
                            code=$"CourseBase-{school.id}",
                            pk="CourseBase",
                            ttl=-1,
                            name=course.name,
                            subject= new IdName { id=course.subject?.id, name=course.subject?.name },
                            period= new IdName { id= course.period?.id, name =course.period?.name },
                            school=school.id,
                            scope="school",
                            no=course.no,
                            creatorId=course.creatorId,
                            desc=course.desc,
                            status=1,
                            grade=0,
                        };
                        //生成新的课程编号
                        string sqlNo = $"select  value c.no from c where c.period.id='{courseBase.period.id}'  ";
                        var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<string>(sqlNo, courseBase.code);
                        if (result.list.IsNotEmpty())
                        {
                            if (period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))>0)
                            {
                                int index = period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id)) +1;
                                var nos = result.list.FindAll(x => !string.IsNullOrWhiteSpace(x) &&  x.StartsWith($"{index}")).ToHashSet<string>();
                                if (nos != null)
                                {
                                    string couresNo = string.Empty;
                                    List<string> order = nos.Where(y => !string.IsNullOrEmpty(y) && Regex.IsMatch(y, @"^\d*$")).OrderBy(x => int.Parse(x)).ToList();
                                    if (!order.Contains($"{index}00"))
                                    {
                                        order.Insert(0, $"{index}00");
                                    }
                                    if (order != null)
                                    {
                                        if (!order.Contains($"{index}00"))
                                        {
                                            order.Insert(0, $"{index}00");
                                        }
                                    }
                                    else { order = new List<string>() { $"{index}00" }; }
                                    for (int i = 0; i < order.Count; i++)
                                    {
                                        couresNo = $"{int.Parse(order[i]) + 1}";
                                        int no = i + 1;
                                        if (no <= order.Count - 1)
                                        {
                                            if (!couresNo.Equals(order[no]))
                                            {
                                                break;
                                            }
                                        }
                                    }
                                    if (string.IsNullOrWhiteSpace(couresNo))
                                    {
                                        couresNo=$"{index}99";
                                    }
                                    courseBase.no=couresNo;
                                }
                                else
                                {
                                    courseBase.no= $"{index}01";
                                }
                            }
                            else
                            {
                                courseBase.no=$"{coureseIndex}99";
                            }
                        }
                        else
                        {
                            if (period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))>0)
                            {
                                courseBase.no= $"{(period.subjects.FindIndex(z => z.id.Equals(courseBase.subject.id))+1)}01";
                            }
                            else
                            {
                                courseBase.no=$"{coureseIndex}99";
                            }
                        }
                    }
                   
                    List<ScheduleTask> schedules = new List<ScheduleTask>();
                    int grade = -1;
                    foreach (var schedule in course.schedule)
                    {
                        if (!string.IsNullOrWhiteSpace(schedule.teacherId) && !string.IsNullOrWhiteSpace(schedule.classId))
                        {
                            schedules.Add(new ScheduleTask() { type="class", groupId=schedule.classId, teacherId=schedule.teacherId, roomId= schedule.room, school=school.id });
                            try {
                                Class clazz = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<Class>(schedule.classId, new PartitionKey($"Class-{school.id}"));
                                var gradeData = SchoolService.GetGrades(school, period.id, new List<int>() { clazz.year }, 1688140800000);
                                if (gradeData.grades.Any() && gradeData.grades.Count>0)
                                {
                                    int.TryParse(gradeData.grades.First(), out grade);
                                }
                            } catch { }
                        }
                        if (!string.IsNullOrWhiteSpace(schedule.teacherId) && !string.IsNullOrWhiteSpace(schedule.stulist))
                        {
                            schedules.Add(new ScheduleTask() { type="teach", groupId=schedule.stulist, teacherId=schedule.teacherId, roomId= schedule.room, school=school.id });
                            if (grade==-1)
                            {
                                _coreAPIHttpService.check=false;
                                var groups = await GroupListService.GetMemberByListids(_coreAPIHttpService, _azureCosmos.GetCosmosClient(), _dingDing, new List<string> { schedule.stulist }, school.id);
                                if (groups.rmembers.IsNotEmpty())
                                {
                                    var a = groups.rmembers.Where(z => z.type==2  && z.year>0).GroupBy(z => z.year).Select(z => new { key = z.Key, list = z.ToList() }).OrderByDescending(y => y.list.Count).FirstOrDefault();
                                    if (a!=null)
                                    {
                                        var gradeData = SchoolService.GetGrades(school, period.id, new List<int>() { a.key }, 1688140800000);
                                        if (gradeData.grades.Any() && gradeData.grades.Count>0)
                                        {
                                            int.TryParse(gradeData.grades.First(), out grade);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (grade>-1)
                    {
                        courseBase.grade=grade;
                    }
                    CourseDto courseDto = new CourseDto();
                    courseDto.courseBase=courseBase;
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(courseBase, new PartitionKey(courseBase.code));
                    if (schedules.IsNotEmpty())
                    {
                        if (semester.currSemester!=null)
                        {
                            string id = $"{semester.studyYear}-{semester.currSemester.id}-{courseBase.id}";
                            string code = $"CourseTask-{school.id}";
                            CourseTask courseTask = new CourseTask
                            {
                                id = id,
                                code = code,
                                pk="CourseTask",
                                ttl=-1,
                                courseId=courseBase.id,
                                year= semester.studyYear,
                                expire= semester.nextSemester.AddDays(-1).ToUnixTimeMilliseconds(),
                                semesterId=semester.currSemester.id,
                                schedules=schedules
                            };
                            courseDto.courseTasks.Add(new CourseTaskDto { courseTask=courseTask, type="school" });
                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(courseTask, new PartitionKey(code));
                        }
                    }
                    coureseIndex = +1;
                    schoolCourseDtos.Add(courseDto);
                }

                List<CourseDto> teacherCourseDtos = new List<CourseDto>();
                foreach (var course in teacherCourses)
                {
                    CourseBase courseBase = new CourseBase()
                    {
                        id= course.id,
                        code=$"CourseBase",
                        pk="CourseBase",
                        ttl=-1,
                        name=course.name,
                        scope="private",
                        no=course.no,
                        creatorId=course.creatorId,
                        desc=course.desc,
                        status=1,
                    };
                    List<ScheduleTask> schedules = new List<ScheduleTask>();
                    foreach (var schedule in course.schedule)
                    {
                        if (!string.IsNullOrWhiteSpace(schedule.teacherId) && !string.IsNullOrWhiteSpace(schedule.classId))
                        {
                            schedules.Add(new ScheduleTask() { type="class", groupId=schedule.classId, teacherId=schedule.teacherId, roomId= schedule.room });
                        }
                        if (!string.IsNullOrWhiteSpace(schedule.teacherId) && !string.IsNullOrWhiteSpace(schedule.stulist))
                        {
                            schedules.Add(new ScheduleTask() { type="teach", groupId=schedule.stulist, teacherId=schedule.teacherId, roomId= schedule.room });

                        }
                    }
                    CourseDto courseDto = new CourseDto();
                    courseDto.courseBase=courseBase;
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(courseBase, new PartitionKey(courseBase.code));
                    if (schedules.IsNotEmpty())
                    {
                        string id = $"{courseBase.id}";
                        string code = $"CourseTask";
                        CourseTask courseTask = new CourseTask
                        {
                            id = id,
                            code = code,
                            pk="CourseTask",
                            ttl=-1,
                            courseId=courseBase.id,
                            schedules=schedules
                        };
                        courseDto.courseTasks.Add(new CourseTaskDto { courseTask=courseTask, type="private" });
                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(courseTask, new PartitionKey(code));
                    }
                    teacherCourseDtos.Add(courseDto);
                }
                return Ok(new { schoolCourseDtos, teacherCourseDtos });
            } catch (Exception ex ){ return Ok($"{ex.Message},{ex.StackTrace}"); }

        }
 
    }
    public class CourseStudentDto
    {
        public CourseBase courseBase { get; set; }
        public List<CourseTask> courseTasks { get; set; } = new List<CourseTask>();

    }
    public class CourseDto { 
        public CourseBase courseBase { get; set; }
        public List<CourseTaskDto> courseTasks { get; set; } = new List<CourseTaskDto>();
      
    }
    public class CourseTaskDto {
        public CourseTask courseTask { get; set; }
        /// <summary>
        /// teacher主任课教师，assistant,协同教师
        /// </summary>
        public string type { get; set; }
    }
}