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;

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 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, AzureServiceBusFactory serviceBus, AzureStorageFactory azureStorage, IConfiguration configuration)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _option = option?.Value;
            _serviceBus = serviceBus;
            _configuration = configuration;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
        }
        /// <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 code = $"CourseBase-{_code}";
                            string baseSql = $"select value c from c where c.period.id='{_periodId}'";
                            List<CourseBase> courseBases = new List<CourseBase>();
                            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname)
                            .GetItemQueryIterator<CourseBase>(queryText: baseSql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey(code) }))
                            {
                                courseBases.Add(item);
                            }
                            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;
                            Azure.Response response = await client.GetContainer(Constant.TEAMModelOS, tbname).DeleteItemStreamAsync(_id.ToString(), new PartitionKey($"CourseBase-{_code}"));
                            //需要联动删除排课
                            string taskCode = $"CourseTask-{_code}";
                            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 => x.StartsWith($"{index}"));
                                                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}'    ");
                                courseBase.creatorId = tmdid;
                                courseBase.code = $"CourseBase-{tmdid}";
                            }
                            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));
                            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 date, DateTimeOffset nextSemester) info = SchoolService.GetSemester(period);
                                    semesterId = info.currSemester.id;
                                    studyYear = info.studyYear;
                                }
                                else
                                {
                                    studyYear = _year.GetInt32();
                                    semesterId=_semesterId.GetString();
                                }
                                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())
                                    {
                                        has_schedule = true;
                                    }
                                }
                                //匹配建议的班级和教师
                                List<Class> classes = new List<Class>();
                                List<SchoolTeacher> teachers = new List<SchoolTeacher>();
                                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.ToString(), $"Teacher-{school}");
                                        teachers = result.list;
                                    }
                                }
                                //当courseTask 为空，则matchedClasses可能会有年级匹配建议升学年的班级清单，
                                //注：比如高二可能会将高三的课程学完，则该高三的课程的学年级应该是手动处理为高中二年级。不区分学期的目的，也是可能存在提前一学期学完第二学期的课程。
                                return Ok(new { studyYear, semesterId, courseTask, matchedClasses = classes, matchedTeachers = teachers.Select(z => new { z.id, z.name, z.subjectIds, z.job, z.periodId, z.picture }) });
                            }
                            else
                            {
                                string taskCode = $"CourseTask-{tmdid}";
                                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-{tmdid}";
                                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-{tmdid}"));
                                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)}) ";
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<CourseBase>(sqlCourse, $"CourseBase-{tmdid}");
                                    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-{tmdid}";
                                        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;
                                            }
                                        }
                                        courseTasks.Add(courseTask);
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).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();
                            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>>();
                            //数据检查
                            //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);
                                if (info.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)
                                        {
                                            ///班级入学年-编号重复的班级
                                            duplicateClasses.Add(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 = $"{info.studyYear}-{info.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 = info.studyYear,
                                        semesterId = info.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 => z.id.Equals(item.courseId));
                                    item.schedules.ForEach(z =>
                                    {
                                        CourseCheckImport courseCheckImport = new CourseCheckImport { name=courseBase?.name, stime=date, 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();
        }

        /// <summary>
        /// 教师任教的课程
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "teacher,admin")]
        [HttpPost("teacher")]
        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();
                if (!request.TryGetProperty("scope", out JsonElement scope)) return BadRequest();
                var client = _azureCosmos.GetCosmosClient();
                switch (true)
                {
                    //任教学校课程和个人课程
                    case bool when $"{grant_type}".Equals("teach", StringComparison.OrdinalIgnoreCase):
                        //个人，
                        //学校，
                        //助教，学校。
                        //助教，个人。
                        break;
                }
            }
            catch (Exception ex)
            {

            }
            return Ok();
        }
    }
}