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;

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")]

        [Authorize(Roles = "IES")]


        public async Task<IActionResult> upsert(JsonElement request) 
        {
            try {
                (string id, _, _, 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("scope", out JsonElement _scope) || !request.TryGetProperty("code", out JsonElement _code))
                            {
                                return BadRequest();
                            }
                            string tbname = $"{_scope}".Equals("school", StringComparison.OrdinalIgnoreCase)?Constant.School:Constant.Teacher;
                            string code = $"CourseBase-{_code}";
                            string baseSql = $"select value c from c ";
                            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 });
                        }
                    case bool when $"{grant_type}".Equals("delete", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("id", out JsonElement _id) || !request.TryGetProperty("scope", out JsonElement _scope) || !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}-{_id}";
                            string taskSql = $"select value c from c ";
                            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("upsert", StringComparison.OrdinalIgnoreCase) :
                        {
                            if (!request.TryGetProperty("course", out JsonElement _course))
                            {
                                return BadRequest();
                            }
                            CourseBase courseBase = _course.ToObject<CourseBase>();
                            courseBase.pk = "CourseBase";
                            if (string.IsNullOrWhiteSpace(courseBase.id))
                            {
                                courseBase.id = Guid.NewGuid().ToString();
                            }
                            string tbname = $"{courseBase.scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? Constant.School : Constant.Teacher;
                            if (courseBase.scope.Equals("school", StringComparison.OrdinalIgnoreCase))
                            {
                                courseBase.school = school;
                                courseBase.creatorId = id;
                                courseBase.code = $"CourseBase-{school}";
                            }
                            else
                            {
                                courseBase.creatorId = id;
                                courseBase.code = $"CourseBase-{id}";
                            }
                            await client.GetContainer(Constant.TEAMModelOS, tbname).UpsertItemAsync(courseBase, new PartitionKey(courseBase.code));
                            return Ok(new { course = courseBase });
                        }
                    case bool when $"{grant_type}".Equals("read-task", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("scope", out JsonElement _scope))
                            {
                                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();
                                if (!request.TryGetProperty("courseId", out JsonElement _courseId)) return BadRequest();
                                int studyYear = -1;
                                string semesterId = string.Empty;
                                if (!request.TryGetProperty("year", out JsonElement _year) || !request.TryGetProperty("semesterId", out JsonElement _semesterId))
                                {
                                    //如果没传，则以当前时间获取学年和学期信息
                                    School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                                    var period = schoolBase.period.Find(x => x.id.Equals($"{_periodId}"));
                                    (Semester currSemester, int studyYear, DateTimeOffset 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}-{_courseId}";
                                string taskId = $"{studyYear}-{semesterId}";
                                Azure.Response response =  await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).ReadItemStreamAsync(taskId, new PartitionKey(taskCode));
                                if (response.Status == 200) { 
                                     CourseTask courseTask=JsonDocument.Parse(response.Content).RootElement.ToObject<CourseTask>();
                                }
                                return Ok(new { studyYear, semesterId, });
                            }
                            else
                            {
                                
                            }
                            break;
                        }
                    case bool when $"{grant_type}".Equals("insert-task", StringComparison.OrdinalIgnoreCase) :
                        {
                            if ( !request.TryGetProperty("scope", out JsonElement _scope))
                            {
                                return BadRequest();
                            }
                            string tbname = $"{_scope}".Equals("school", StringComparison.OrdinalIgnoreCase) ? Constant.School : Constant.Teacher;
                            break;
                        }
                    //按照模板导入进行数据转换并且进行检查
                    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 sqlName = new StringBuilder(" select  value c from c ");
                            sqlName.Append($" where c.name in({string.Join(",", courseCheckImports.Select(z=>$"'{z.name}'"))})  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 = "专业不存在！" });
                                }
                                sqlName.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: sqlName.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"CourseBase-{school}") }))
                            {
                                courseBases.Add(item);
                            }
                            HashSet<CourseCheckImport> courseInvalidImports = new HashSet<CourseCheckImport>();
                            var nameInvalidImports = courseCheckImports.ExceptBy(courseBases.Select(x => x.name),z=>z.name);
                            //保留课程名称存在的排课信息
                            if (nameInvalidImports != null && nameInvalidImports.Any())
                            {
                                foreach (var nameInvalidImport in nameInvalidImports)
                                {
                                    nameInvalidImport.invalidCode =1;
                                    courseInvalidImports.Add(nameInvalidImport);
                                }
                                courseCheckImports.RemoveAll(z=> nameInvalidImports.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.Teacher)
                            .GetItemQueryIterator<IdNameCode>(queryText: sqlTmdid.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey("Base") }))
                            {
                                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 = courseCheckImports.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>>();
                            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, 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;
                                }
                                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.name.Equals(item.name));
                                string taskId = $"{info.studyYear}-{info.currSemester.id}";
                                string taskCode = $"CourseTask-{school}-{courseBase.id}";
                                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= new List<ScheduleTime> { scheduleTime }
                                           }
                                        }
                                    };
                                    courseTasks.Add(courseTask);
                                }
                                else {
                                    var scheduleTask= courseTask.schedules.Find(z => z.type.Equals(item.type) && z.groupId.Equals(groupId) && z.teacherId.Equals(teacherId));
                                    if (scheduleTask == null)
                                    {
                                        courseTask.schedules.Add(new ScheduleTask()
                                        {
                                            roomId = roomId,
                                            groupId = groupId,
                                            type = item.type,
                                            teacherId = teacherId,
                                            times = new List<ScheduleTime> { scheduleTime }
                                        });
                                    }
                                    else {
                                        scheduleTask.roomId = roomId;
                                        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);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                checkedCount++;
                            }
                            //生成检查结果token,有效期5分钟
                            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, courseInvalidImports, checkToken });
                        }
                    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();
                        }
                }
            } catch (Exception ex) {
               await _dingDing.SendBotMsg($"{_option.Location},课程处理异常，{ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
            }
            return Ok();
        }
    }
    
}