TEAMModelOS/TEAMModelOS/Controllers/Common/HomeworkController.cs

using Azure.Cosmos;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.Models.Dto;
using TEAMModelOS.SDK.Models;

using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Helper.Common.StringHelper;
using TEAMModelOS.Filter;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Options;
using System.Net.Http;
using TEAMModelOS.Models;
using Azure.Messaging.ServiceBus;
using System.IO;
using System.Linq;
using HTEXLib.COMM.Helpers;

namespace TEAMModelOS.Controllers.Learn
{
    // TODO 代码优化

    /// <summary>
    /// 作业活动
    /// </summary>
    /// 
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [Route("common/homework")]
    [ApiController]
    public class HomeworkController : ControllerBase
    {
        private readonly AzureRedisFactory _azureRedis;
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly SnowflakeId _snowflakeId;
        private readonly AzureServiceBusFactory _serviceBus;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly AzureStorageFactory _azureStorage;
        private readonly IHttpClientFactory _clientFactory;
        public IConfiguration _configuration { get; set; }
        public HomeworkController(AzureCosmosFactory azureCosmos, AzureServiceBusFactory serviceBus, SnowflakeId snowflakeId, DingDing dingDing, IOptionsSnapshot<Option> option,
            AzureRedisFactory azureRedis, AzureStorageFactory azureStorage, IHttpClientFactory clientFactory, IConfiguration configuration)
        {
            _snowflakeId = snowflakeId;
            _serviceBus = serviceBus;
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _option = option?.Value;
            _azureRedis = azureRedis;
            _azureStorage = azureStorage;
            _clientFactory = clientFactory;
            _configuration = configuration;
        }

        /// <summary>
        /// 新增 或 修改投票活动
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("upsert")]
        [AuthToken(Roles = "teacher,admin", Permissions = "schoolAc-upd")]
        public async Task<IActionResult> Upsert(Homework homework)
        {
            try {
                var (userid, _, _, school) = HttpContext.GetAuthTokenInfo();
                var client = _azureCosmos.GetCosmosClient();
                homework.pk = "Homework";
                long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                if (!homework.code.StartsWith("Homework-"))
                {
                    homework.code = $"Homework-{homework.code}";
                }
                homework.creatorId = userid;
                homework.createTime = now;
                homework.startTime = now;
                homework.ttl = -1;
                if (string.IsNullOrEmpty(homework.id))
                {
                    homework.id = Guid.NewGuid().ToString();
                    //if (homework.startTime > now)
                    //{
                    //    homework.progress = "pending";
                    //}
                    //else
                    //{
                    //    homework.progress = "going";
                    //}
                    homework.progress = "going";
                    var messageBlob = new ServiceBusMessage();
                    string blobcntr = null;
                    if (homework.scope.Equals("school"))
                    {
                        blobcntr = homework.school;
                        homework.size = await _azureStorage.GetBlobContainerClient(homework.school).GetBlobsSize($"homework/{homework.id}");
                        messageBlob = new ServiceBusMessage(new { id = Guid.NewGuid().ToString(), progress = "insert", root = $"homework/{homework.id}", name = $"{homework.school}" }.ToJsonString());
                    }
                    else
                    {
                        blobcntr = homework.creatorId;
                        homework.size = await _azureStorage.GetBlobContainerClient(homework.creatorId).GetBlobsSize($"homework/{homework.id}");
                        messageBlob = new ServiceBusMessage(new { id = Guid.NewGuid().ToString(), progress = "insert", root = $"homework/{homework.id}", name = $"{homework.creatorId}" }.ToJsonString());
                    }
                    messageBlob.ApplicationProperties.Add("name", "BlobRoot");
                    var ActiveTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");
                    await _serviceBus.GetServiceBusClient().SendMessageAsync(ActiveTask, messageBlob);
                    homework.recordUrl = $"/homework/{homework.id}/record.json";
                    var cods = new { records = new List<string>(), userids = new List<string>(), question = new List<QuestionRecord>() };
                    await _azureStorage.UploadFileByContainer(blobcntr, cods.ToJsonString(), "homework", $"{homework.id}/record.json");
                    homework = await client.GetContainer(Constant.TEAMModelOS, "Common").CreateItemAsync(homework, new PartitionKey($"{homework.code}"));
                }
                else
                {
                    string blobcntr = null;
                    var response = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync(homework.id, new PartitionKey($"{homework.code}"));
                    var messageBlob = new ServiceBusMessage();
                    if (homework.scope.Equals("school"))
                    {
                        blobcntr = homework.school;
                        homework.size = await _azureStorage.GetBlobContainerClient(homework.school).GetBlobsSize($"homework/{homework.id}");
                        messageBlob = new ServiceBusMessage(new { id = Guid.NewGuid().ToString(), progress = "update", root = $"homework/{homework.id}", name = $"{homework.school}" }.ToJsonString());
                    }
                    else
                    {
                        blobcntr = homework.creatorId;
                        homework.size = await _azureStorage.GetBlobContainerClient(homework.creatorId).GetBlobsSize($"homework/{homework.id}");
                        messageBlob = new ServiceBusMessage(new { id = Guid.NewGuid().ToString(), progress = "update", root = $"homework/{homework.id}", name = $"{homework.creatorId}" }.ToJsonString());
                    }
                    messageBlob.ApplicationProperties.Add("name", "BlobRoot");
                    var ActiveTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");
                    await _serviceBus.GetServiceBusClient().SendMessageAsync(ActiveTask, messageBlob);
                    if (response.Status == 200)
                    {
                        using var json = await JsonDocument.ParseAsync(response.ContentStream);
                        var info = json.ToObject<Homework>();
                        if (info.progress.Equals("going"))
                        {
                            return Ok(new { v = "活动正在进行中" });
                        }
                        if (homework.startTime > now)
                        {
                            homework.progress = "pending";
                        }
                        else
                        {
                            homework.progress = "going";
                        }
                        homework.progress = info.progress;
                        homework.recordUrl = $"/homework/{homework.id}/record.json";
                        homework = await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(homework, info.id, new PartitionKey($"{info.code}"));
                    }
                    else
                    {
                        //if (homework.startTime > now)
                        //{
                        //    homework.progress = "pending";
                        //}
                        //else
                        //{
                        //    homework.progress = "going";
                        //}
                        homework.progress = "going";
                        homework.recordUrl = $"/homework/{homework.id}/record.json";
                        var cods = new { records = new List<string>(), userids = new List<string>(), question = new List<QuestionRecord>() };
                        await _azureStorage.UploadFileByContainer(blobcntr, cods.ToJsonString(), "homework", $"{homework.id}/record.json");
                        homework = await client.GetContainer(Constant.TEAMModelOS, "Common").CreateItemAsync(homework, new PartitionKey($"{homework.code}"));
                    }
                }
                return Ok(new { homework });
            } catch (CosmosException ex) {
                return Ok(new { error = ex.Status });
            }
            catch (Exception ex)
            {
                return Ok(new { error = 400 });
            }
        }


        /// <summary>
        /// 查询问卷调查,用于列表，编辑，查看
        /// </summary>
        /// <data>
        ///Survey-学校/教师编码  活动分区        !"code":"hbcn"/1606285227 
        ///时间筛选范围开始时间 默认30天之前   ?"stime":1608274766154  
        ///时间筛选范围结束时间 默认当前时间   ?"etime":1608274766666 
        ///每页大小     ?"count":10/null/Undefined  
        ///分页Token    ?"continuationToken":Undefined/null/"[{\"token\":\"+RID:~omxMAP3ipcSEEwAAAAAAAA==#RT:2#TRC:20#ISV:2#IEO:65551#QCF:1#FPC:AYQTAAAAAAAAiRMAAAAAAAA=\",\"range\":{\"min\":\"\",\"max\":\"FF\"}}]"
        /// 当前状态    ?"progress":Undefined/null/"" 表示两种状态都要查询/ "going"/"finish" 表示查询进行中/ 或者已完成 学生端只能查询正在进行或已经结束 going 已发布|finish 已结束  
        /// </data>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("find")]
        [AuthToken(Roles = "teacher,admin,student", Permissions = "schoolAc-read,schoolAc-upd")]
        public async Task<IActionResult> Find(JsonElement request) {
            try
            {
                var client = _azureCosmos.GetCosmosClient();
                var (userid, _, _, school) = HttpContext.GetAuthTokenInfo();
                //必须有学校或者教师编码
                if (!request.TryGetProperty("code", out JsonElement code)) return BadRequest();
                //开始时间，默认最近三十天
                var stimestamp = DateTimeOffset.UtcNow.AddDays(-30).ToUnixTimeMilliseconds();
                if (request.TryGetProperty("stime", out JsonElement stime))
                {
                    if (long.TryParse($"{stime}", out long data))
                    {
                        stimestamp = data;
                    };
                };
                //默认当前时间
                var etimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                if (request.TryGetProperty("etime", out JsonElement etime))
                {
                    if (long.TryParse($"{etime}", out long data))
                    {
                        etimestamp = data;
                    };

                };
                var progresssql = "";
                if (request.TryGetProperty("progress", out JsonElement progress))
                {

                    if (!progress.ValueKind.Equals(JsonValueKind.Undefined) && !progress.ValueKind.Equals(JsonValueKind.Null) && progress.ValueKind.Equals(JsonValueKind.String))
                    {
                        progresssql = $" and c.progress='{progress}' ";
                    }
                }
                string continuationToken = null;
                //默认不指定返回大小
                int? topcout = null;
                if (request.TryGetProperty("count", out JsonElement jcount))
                {
                    if (int.TryParse($"{jcount}", out int data))
                    {
                        topcout = data;
                    }
                };
                //是否需要进行分页查询，默认不分页
                bool iscontinuation = false;
                //如果指定了返回大小
                if (request.TryGetProperty("continuationToken", out JsonElement continuation))
                {
                    //指定了cancellationToken 表示需要进行分页
                    if (!continuation.ValueKind.Equals(JsonValueKind.Null) && !continuation.ValueKind.Equals(JsonValueKind.Undefined))
                    {
                        continuationToken = continuation.GetString();
                        iscontinuation = true;
                    }
                };
                List<Homework> homeworks = new List<Homework>();
                var query = $"select c.owner, c.id,c.name,c.code,c.startTime,c.endTime,c.progress,c.classes,c.scope,c.school from c where  c.createTime >= {stimestamp} and c.createTime <= {etimestamp}  {progresssql } and c.ttl=-1 ";
                if (string.IsNullOrEmpty(school))
                {
                    query = $"{query} and c.scope='private' ";
                }
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Common").GetItemQueryIterator<Homework>(queryText: query,
                    requestOptions: new QueryRequestOptions() { MaxItemCount = topcout, PartitionKey = new PartitionKey($"Homework-{code}") }))
                {
                    if (!string.IsNullOrEmpty(school))
                    {
                        //只能查出相关学校的
                        if (!item.scope.Equals("private") && !string.IsNullOrEmpty(item.school) && item.school.Equals(school))
                        {
                            homeworks.Add(item);
                        }
                        //和自己私人发布的 
                        if (item.scope.Equals("private"))
                        {
                            homeworks.Add(item);
                        }
                    }
                    else
                    {
                        homeworks.Add(item);
                    }
                }
                return Ok(new { homeworks });
            }
            catch (CosmosException ex)
            {
                return Ok(new { error = ex.Status });
            }
            catch (Exception ex) {
                return Ok(new { error = 400 });
            }
        }

        ///<summary>
        /// 查询问卷调查,用于创建者列表，编辑，查看，作答人员查看
        /// </summary>
        /// <data>
        ///    ! "id":"3c075347-75ef-4bcb-ae03-68678d02d5ef",
        ///    ! "code":"Survey-hbcn"/"code":"Survey-1606285227"
        /// </data>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("find-id")]
        [AuthToken(Roles = "teacher,admin,student", Permissions = "schoolAc-read,schoolAc-upd")]
        public async Task<IActionResult> FindById(JsonElement request) {
            Homework work = null;
            var client = _azureCosmos.GetCosmosClient();
            var (userid, _, _, school) = HttpContext.GetAuthTokenInfo();
            //活动id
            if (!request.TryGetProperty("id", out JsonElement id)) return BadRequest();
            //活动分区
            if (!request.TryGetProperty("code", out JsonElement _code)) return BadRequest();
            try
            {

                work = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<Homework>(id.GetString(), new PartitionKey($"Homework-{_code}"));
                return Ok(new { work, status = 200 });
            }
            catch (CosmosException ex)
            {

                return Ok(new { homework = work, status = 404 });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OS，{_option.Location}，common/survey/find-id\n{ex.Message}{ex.StackTrace}\n{id}\n{_code}  ", GroupNames.醍摩豆服務運維群組);
                return Ok(new { work, status = 404 });
            }
        }

        /// <summary>
        /// 删除问卷调查   TODO 使用ttl删除，并处理相关事务逻辑
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("delete")]
        [AuthToken(Roles = "teacher,admin", Permissions = "schoolAc-upd")]
        public async Task<IActionResult> Delete(JsonElement request) {
            try {
                var client = _azureCosmos.GetCosmosClient();
                var (userid, _, _, school) = HttpContext.GetAuthTokenInfo();
                if (!request.TryGetProperty("id", out JsonElement _id)) return BadRequest();
                if (!request.TryGetProperty("code", out JsonElement __code)) return BadRequest();
                Homework homeworkd = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<Homework>(_id.GetString(), new PartitionKey($"Homework-{__code}"));
                bool flag = false;
                //必须是本人或者这个学校的管理者才能删除
                if (homeworkd.creatorId == userid)
                {
                    flag = true;
                }
                else
                {
                    if (homeworkd.scope.Equals("school") && homeworkd.school.Equals(school))
                    {
                        flag = true;
                    }
                }
                if (flag)
                {
                    //使用ttl删除，并处理相关事务逻辑
                    homeworkd.ttl = 1;
                    homeworkd.status = 404;
                    homeworkd = await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(homeworkd, homeworkd.id, new PartitionKey($"{homeworkd.code}"));

                    //删除blob 相关资料
                    await _azureStorage.GetBlobServiceClient().DeleteBlobs(_dingDing, $"{__code}".Replace("Homework-", ""), new List<string> { Path.Combine("homework", homeworkd.id) + "/" });
                    //通知删除信息
                    var messageBlob = new ServiceBusMessage(new { id = Guid.NewGuid().ToString(), progress = "delete", root = $"homework/{homeworkd.id}", name = $"{__code}" }.ToJsonString());
                    messageBlob.ApplicationProperties.Add("name", "BlobRoot");
                    var ActiveTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");
                    await _serviceBus.GetServiceBusClient().SendMessageAsync(ActiveTask, messageBlob);
                    await _dingDing.SendBotMsg($"{_option.Location}-作业活动【{homeworkd.name}-{homeworkd.id}】被删除", GroupNames.成都开发測試群組);
                    return Ok(new { flag });
                }
                else
                {
                    return Ok(new { flag });
                }

            } catch (CosmosException ex) {
                return Ok(new { flag = false, error = 404 });
            }
        }
        public class TypeUser { 
            public string userid { get; set; }
            
            public string userType { get; set; }
            public string userSchool { get; set; }
         
            public string username { get; set; }
            public List<TypeUserClass> classes { get; set; } = new List<TypeUserClass>();
        }
        public class TypeUserClass
        {
            public string id { get; set; }
            public string name { get; set; }
        }
        public class HomeworkUser
        {
            public string userid { get; set; }
            public string userType { get; set; }
            public string userSchool { get; set; }
            public long submitTime { get; set; }
            public double score { get; set; } = -1;
            public double star { get; set; } = -1;
            public double teacherStar { get; set; } = -1;
            public bool submit { get; set; }
           
            public string username { get; set; }
            public List<TypeUserClass> classes { get; set; } = new List<TypeUserClass>();
            public List<string> replies { get; set; } = new List<string>();
        }
        /// <summary>
        /// 互动
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("interact")]
        [AuthToken(Roles = "teacher,student,admin")]
        public async Task<IActionResult> Interact(JsonElement request)
        {
            if (!HttpContext.Items.TryGetValue("Scope", out object _scope)) return BadRequest();
            var client = _azureCosmos.GetCosmosClient();
            var (userid, name, _, school) = HttpContext.GetAuthTokenInfo();
            long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            if (!request.TryGetProperty("opt", out JsonElement _opt)) return BadRequest();
            if (!request.TryGetProperty("id", out JsonElement _id)) return BadRequest();
            if (!request.TryGetProperty("code", out JsonElement __code)) return BadRequest();
           // if (!request.TryGetProperty("teacher", out JsonElement _teacher)) return BadRequest();
            if (!request.TryGetProperty("targetType", out JsonElement _targetType)) return BadRequest();
            string tbname = "Student";
            if ($"{_targetType}".Equals("research", StringComparison.OrdinalIgnoreCase))
            {
                tbname = "Teacher";

            }
            else if ($"{_targetType}".Equals("student", StringComparison.OrdinalIgnoreCase))
            {
                tbname = "Student";
            }
            
            try
            {
                Homework homework = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<Homework>($"{_id}", new PartitionKey($"Homework-{__code}"));
                string teacher = homework.creatorId;
                switch (true)
                {   //作答记录
                    case bool when $"{_opt}".Equals("AnswerRecordAll", StringComparison.OrdinalIgnoreCase):
                        try
                        {   // userType 为student 时，userid 为校内账号，且userSchool 需要有学校编码。
                            //userType 为tmdid 时,userid 为醍摩豆账号，且userSchool 可以为空。
                           // if (!request.TryGetProperty("typeUsers", out JsonElement _typeUsers)) return BadRequest();
                            if (!request.TryGetProperty("listIds", out JsonElement _listIds)) return BadRequest();
                            List<string> listIds = _listIds.ToJsonString().ToObject<List<string>>();
                            List<TypeUser> typeUsers = new List<TypeUser>();
                            List<ClassListInfo> classInfos = new List<ClassListInfo>();
                            if ($"{_targetType}".Equals("research", StringComparison.OrdinalIgnoreCase))
                            {
                                (List<RMember> tmdinfos, List<RGroupList> classInfo) = await GroupListService.GetStutmdidListids(client, _dingDing, listIds, homework.school);
                                // (List<TmdInfo> tmdInfos, List<ClassListInfo> classInfos) = await TriggerStuActivity.GetTchList(client, _dingDing, ids, $"{school}");
                                //(List<TmdInfo> tmdinfos,  List<ClassListInfo> classInfo) = await TriggerStuActivity.GetTchList(client, _dingDing, listIds, $"{homework.school}");

                                if (tmdinfos.IsNotEmpty())
                                {
                                   
                                    tmdinfos.ForEach(x => {
                                        var clases= classInfo.Where(y => y.members.Select(z => z.id).Contains(x.id)).ToList() ;
                                        typeUsers.Add(new TypeUser() { userid = x.id, userType = "tmdid", username = x.name, classes = clases.Select(x=>new TypeUserClass{id= x.id,name=x.name}).ToList() });
                                    });
                                }
                            }
                            else {
                                (List<TmdInfo> tmdinfos, List<StuInfo> students, List<ClassListInfo> classInfo) = await TriggerStuActivity.GetStuListInStu(client, _dingDing, listIds, school);

                                if (tmdinfos.IsNotEmpty())
                                {
                                    tmdinfos.ForEach(x => {
                                        var clases = classInfo.Where(y => y.tmdInfos.Select(z => z.id).Contains(x.id)).ToList();
                                        typeUsers.Add(new TypeUser() { userid = x.id, userType = "tmdid", username = x.name, classes = clases.Select(x => new TypeUserClass { id = x.id, name = x.name }).ToList() });
                                    });
                                }
                                if (students.IsNotEmpty())
                                {
                                    students.ForEach(x => {
                                        var clases = classInfo.Where(y => y.stuInfos.Select(z => z.id).Contains(x.id)).ToList();
                                        typeUsers.Add(new TypeUser() { userid = x.id, userType = "student", username = x.name, userSchool = x.code.Replace("Base-", ""), classes = clases.Select(x => new TypeUserClass { id = x.id, name = x.name }).ToList() });
                                    });
                                }
                            }
                                
                            List<dynamic> rscs = new List<dynamic>();
                            
                            string debateCode = "";
                            string debateTbname = "";
                            if (homework.scope.Equals("school"))
                            {
                                debateTbname = "School";
                                debateCode = $"Debate-{homework.school}";
                            }
                            else
                            {
                                debateTbname = "Teacher";
                                debateCode = $"Debate-{homework.creatorId}";
                            }
                            List<Debate> debates = new List<Debate>();
                            string sql = $"select value(c) from c where c.comid='{_id}'";
                            await foreach (var item in  client.GetContainer(Constant.TEAMModelOS, debateTbname).GetItemQueryIterator<Debate>(queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey(debateCode) }))
                            {
                                debates.Add(item);
                            }
                            List<HomeworkUser> users = new List<HomeworkUser>();
                            foreach (var typeuser in typeUsers) {
                                var us= users.Find(x => x.userid.Equals(typeuser.userid));
                                if (us != null) { continue; }
                                HomeworkUser user = new HomeworkUser() { userid=typeuser.userid,userSchool=typeuser.userSchool,userType=typeuser.userType,username=typeuser.username,classes=typeuser.classes};
                                string partition = $"HomeworkRecord-{typeuser.userid}";
                                if (typeuser.userType.Equals("student"))
                                {
                                    partition = $"HomeworkRecord-{typeuser.userSchool}-{typeuser.userid}";
                                }
                                else
                                {
                                    partition = $"HomeworkRecord-{typeuser.userid}";
                                }
                                HomeworkRecord record = null;
                                try
                                {
                                    record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<HomeworkRecord>($"{_id}", new PartitionKey(partition));
                                    double star = -1;
                                    List<double> stars = record.comments.Select(x => x.star).ToList();
                                    if (stars.IsNotEmpty())
                                    {
                                        star = stars.Sum() / stars.Count;
                                    }
                                    user.submit = true;
                                    user.star = star;
                                    user.score = record.score;
                                    user.submitTime = record.time;
                                    // user.username = typeuser.username;
                                    var teacherComment = record.comments.Where(x => x.identity.Equals("teacher") && record.teacher.Equals(userid)).FirstOrDefault();
                                    if (teacherComment != null)
                                    {
                                        user.teacherStar = teacherComment.star;
                                        List<string> replies = new List<string>();
                                        teacherComment.replyIds.ForEach(x => {
                                            var reply = debates.SelectMany(x => x.replies).ToList().Find(r => r.id.Equals(x));
                                            if (reply != null)
                                            {
                                                replies.Add(reply.comment);
                                            }
                                        });
                                        user.replies = replies;
                                    }
                                }
                                catch (CosmosException ex)
                                {
                                    user.submit = false;
                                    record = null;
                                }
                                users.Add(user);
                            }
                            return Ok(new { users });
                        }
                        catch (CosmosException ex)
                        {
                            return Ok(new { error = 404 });
                        }
                    //作答记录
                    case bool when $"{_opt}".Equals("AnswerRecord", StringComparison.OrdinalIgnoreCase):
                        try
                        {   // userType 为student 时，userid 为校内账号，且userSchool 需要有学校编码。
                            //userType 为tmdid 时,userid 为醍摩豆账号，且userSchool 可以为空。
                            if (!request.TryGetProperty("userid", out JsonElement _userid)) return BadRequest();
                            if (!request.TryGetProperty("userType", out JsonElement _userType)) return BadRequest();
                            string partition = $"HomeworkRecord-{_userid}";
                            if ($"{_userType}".Equals("student"))
                            {
                                request.TryGetProperty("userSchool", out JsonElement _userSchool);
                                partition = $"HomeworkRecord-{_userSchool}-{_userid}";
                            }
                            HomeworkRecord record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<HomeworkRecord>($"{_id}", new PartitionKey(partition));
                            return Ok(new { record });
                        }
                        catch (CosmosException ex) {
                            return Ok(new {error=404 });
                        }
                    //提交答案
                    case bool when $"{_opt}".Equals("SubmitAnswer", StringComparison.OrdinalIgnoreCase):
                        if (!request.TryGetProperty("content", out JsonElement _content)) return BadRequest();
                        request.TryGetProperty("answer", out JsonElement _answer);
                        string partitionKey = $"HomeworkRecord-{userid}";
                        if ($"{_scope}".Equals(Constant.ScopeStudent))
                        {
                            partitionKey = $"HomeworkRecord-{school}-{userid}";
                        }
                        List<Attachment> content = _content.ToObject<List<Attachment>>();
                        int taskStatus = -1;
                        byte msgid = 0;
                        if (content != null)
                        {
                            try
                            {
                                HomeworkRecord record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<HomeworkRecord>($"{_id}", new PartitionKey(partitionKey));
                                record.content = content;
                                record.answer = $"{_answer}";
                                record.submitCount += 1;
                                await client.GetContainer(Constant.TEAMModelOS, tbname).ReplaceItemAsync<HomeworkRecord>(record, $"{_id}", new PartitionKey(partitionKey));
                                taskStatus = 1;
                                msgid = 1;
                            }
                            catch (CosmosException ex)
                            {
                                if (ex.Status == 404)
                                {
                                    HomeworkRecord record = new HomeworkRecord
                                    {
                                        teacher = $"{teacher}",
                                        school = school,
                                        id = $"{_id}",
                                        code = partitionKey,
                                        content = content,
                                        answer = $"{_answer}",
                                        pk = "HomeworkRecord",
                                        ttl = -1,
                                        time = now,
                                        submitCount = 1,
                                        comid = Guid.NewGuid().ToString()
                                    };
                                    record = await client.GetContainer(Constant.TEAMModelOS, tbname).CreateItemAsync<HomeworkRecord>(record, new PartitionKey(partitionKey));
                                    taskStatus = 1;
                                    msgid = 1;
                                }
                            }
                            //TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO 写入方便教师查看的作答记录
                            try
                            {
                                if ($"{_scope}".Equals(Constant.ScopeStudent)) {
                                    StuActivity activity = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuActivity>($"{_id}", new PartitionKey($"Activity-{school}-{userid}"));
                                    activity.taskStatus = taskStatus;
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuActivity>(activity, $"{_id}", new PartitionKey($"Activity-{school}-{userid}"));
                                }
                                if ($"{_scope}".Equals(Constant.ScopeTmdUser))
                                {
                                    StuActivity activity = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuActivity>($"{_id}", new PartitionKey($"Activity-{userid}"));
                                    activity.taskStatus = taskStatus;
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuActivity>(activity, $"{_id}", new PartitionKey($"Activity-{userid}"));
                                }
                                if ($"{_scope}".Equals(Constant.ScopeTeacher))
                                {
                                    StuActivity activity = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").ReadItemAsync<StuActivity>($"{_id}", new PartitionKey($"Activity-{userid}"));
                                    activity.taskStatus = taskStatus;
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync<StuActivity>(activity, $"{_id}", new PartitionKey($"Activity-{userid}"));
                                }
                            }
                            catch (CosmosException ex)
                            {
                                taskStatus = -1;
                            }
                            return Ok(new { msgid, taskStatus });
                        }
                        else {
                            return Ok(new { msgid, taskStatus ,error =400});
                        }
                    //评论
                    case bool when $"{_opt}".Equals("ReadAllComment", StringComparison.OrdinalIgnoreCase):
                        // userType 为student 时，userid 为校内账号，且userSchool 需要有学校编码。
                        //userType 为tmdid 时,userid 为醍摩豆账号，且userSchool 可以为空。
                        try 
                        {
                            if (!request.TryGetProperty("userid", out JsonElement _userid)) return BadRequest();
                            if (!request.TryGetProperty("userType", out JsonElement __userType)) return BadRequest();
                            string _partition = $"HomeworkRecord-{_userid}";
                            string userSchool = school;
                            if ($"{__userType}".Equals("student"))
                            {
                                request.TryGetProperty("userSchool", out JsonElement _userSchool);
                                userSchool = $"{_userSchool}";
                                _partition = $"HomeworkRecord-{_userSchool}-{_userid}";
                            }
                            
                            HomeworkRecord record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<HomeworkRecord>($"{_id}", new PartitionKey(_partition));
                            string debateCode = "";
                            string debateTbname = "";
                            if (homework.scope.Equals("school"))
                            {
                                debateTbname = "School";
                                debateCode = $"Debate-{homework.school}";
                            }
                            else
                            {
                                debateTbname = "Teacher";
                                debateCode = $"Debate-{homework.creatorId}";
                            }
                            Debate debate = null; 
                            try
                            {
                                debate = await client.GetContainer(Constant.TEAMModelOS, debateTbname).ReadItemAsync<Debate>($"{record.comid}", new PartitionKey(debateCode));
                            } catch (CosmosException ex) {
                                debate = null;
                            }
                            double star = -1;
                            List<double> stars = record.comments.Select(x => x.star).ToList();
                            if (stars.IsNotEmpty()) {
                                star = stars.Sum() / stars.Count;
                            }
                            List<dynamic> comments = new List<dynamic>();
                            if (debate != null) {
                                record.comments.ForEach(y => {
                                    List<dynamic> replies = new List<dynamic>();
                                    y.replyIds.ForEach(x => {
                                        var reply = debate.replies.Find(r => r.id.Equals(x));
                                        if (reply != null)
                                        {
                                            replies.Add(new { reply.comment ,reply.time} );
                                        }
                                    });
                                    comments.Add(new
                                    {
                                        identity =  y.identity,
                                        star = y.star,
                                        replies = replies,
                                        userid = y.userid,
                                        username = y.username,
                                        userType = y.userType,
                                        userSchool = userSchool
                                    });
                                });
                            }
                            return Ok(new { star, comments, record });
                        }
                        catch (CosmosException ex) {
                            return Ok(new { error = 404 });
                        }
                    case bool when $"{_opt}".Equals("CommentAndStar", StringComparison.OrdinalIgnoreCase):
                        try
                        {
                            // userType 为student 时，userid 为校内账号，且userSchool 需要有学校编码。
                            //userType 为tmdid 时,userid 为醍摩豆账号，且userSchool 可以为空。
                            if (!request.TryGetProperty("userid", out JsonElement __userid)) return BadRequest();
                            if (!request.TryGetProperty("userName", out JsonElement __userName)) return BadRequest();
                            if (!request.TryGetProperty("userType", out JsonElement __userType)) return BadRequest();
                            string userSchool = school;
                            string _partition = $"HomeworkRecord-{__userid}";
                            if ($"{__userType}".Equals("student"))
                            {
                                request.TryGetProperty("userSchool", out JsonElement _userSchool);
                                userSchool = $"{_userSchool}";
                                _partition = $"HomeworkRecord-{_userSchool}-{__userid}";
                            }
                            if (!request.TryGetProperty("comment", out JsonElement _comment)) return BadRequest();
                            if (!request.TryGetProperty("star", out JsonElement _star)) return BadRequest();
                            double star = -1;
                            double.TryParse($"{_star}",out   star);
                            HomeworkRecord record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<HomeworkRecord>($"{_id}", new PartitionKey(_partition));
                            ///话题对象，id为学生的作答记录的comid ,根据scope确定，  code 为Debate-{schoolId}，作业活动所在的学校编码|Debate-{teacherId}，作业活动所在的教师编码
                            string debateCode = "";
                            string debateTbname = "";
                            if (homework.scope.Equals("school"))
                            {
                                debateTbname = "School";
                                debateCode = $"Debate-{homework.school}";
                            }
                            else {
                                debateTbname = "Teacher";
                                debateCode = $"Debate-{homework.creatorId}";
                            }
                            string userType = $"{_scope}".Equals("student") ? "student" : "tmdid";
                            string replyId = Guid.NewGuid().ToString();
                            DebateReply debateReply = new DebateReply
                            {
                                atUserType = $"{__userType}",
                                userType = userType,
                                id = replyId,
                                pid = $"{record.comid}",
                                tmdid = userid,
                                tmdname = name,
                                school= $"{userSchool}",
                                comment = $"{_comment}",
                                atTmdid = $"{__userid}",
                                atTmdname = $"{__userName}" ,
                                time = now
                            };
                            Debate debate = null;
                            try 
                            {
                                debate = await client.GetContainer(Constant.TEAMModelOS, debateTbname).ReadItemAsync<Debate>($"{record.comid}", new PartitionKey(debateCode));
                                debate.replies.Add(debateReply);
                                await client.GetContainer(Constant.TEAMModelOS, debateTbname).ReplaceItemAsync<Debate>(debate,$"{record.comid}", new PartitionKey(debateCode));
                            } catch (CosmosException ex) {
                                debate = new Debate
                                {
                                    userType = $"{__userType}",
                                    comid = $"{homework.id}",
                                    code = debateCode,
                                    id = $"{record.comid}",
                                    tmdid = $"{__userid}",
                                    tmdname = $"{__userName}",
                                    title = $"{__userName}-{homework.name}",
                                    time = now,
                                    comment = "",
                                    school =homework.school,
                                    replies = new List<DebateReply>() { debateReply },
                                    source = "homework",
                                    openType = 0,
                                    ttl = -1,
                                    pk = "Debate"
                                };
                                await client.GetContainer(Constant.TEAMModelOS, debateTbname).CreateItemAsync<Debate>(debate, new PartitionKey(debateCode));
                            }
                            string identity = "student";
                            if (userid.Equals($"{homework.creatorId}"))
                            {
                                identity = "teacher";
                            }
                            HomeworkComment homeworkComment = record.comments.Find(x => x.userid.Equals(userid));
                            if (homeworkComment != null)
                            {
                                homeworkComment.star = star;
                                // homeworkComment.replyIds.Add(replyId);
                                homeworkComment.replyIds = new List<string> { replyId };
                            }
                            else
                            {
                                homeworkComment = new HomeworkComment
                                {
                                    star= star,
                                    identity = identity,
                                    userType = $"{_scope}".Equals("student") ? "student" : "tmdid",
                                    userid = userid,
                                    username = name,
                                    school = school,
                                    replyIds = new List<string> { replyId }
                                };
                                record.comments.Add(homeworkComment);
                            }
                            record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReplaceItemAsync<HomeworkRecord>(record,$"{_id}", new PartitionKey(_partition));
                            return Ok(new { star,  userid, username=name, identity, userType, userSchool, replies = new List<string>() { $"{_comment}" } });
                        }
                        catch (CosmosException ex)
                        {
                            return Ok(new { error = 404 });
                        }
                        catch (Exception ex) {
                            return BadRequest(new { error = 400 });
                        }
                    //打分
                    case bool when $"{_opt}".Equals("MarkScore", StringComparison.OrdinalIgnoreCase):
                        try
                        {
                            // userType 为student 时，userid 为校内账号，且userSchool 需要有学校编码。
                            //userType 为tmdid 时,userid 为醍摩豆账号，且userSchool 可以为空。
                            if (!request.TryGetProperty("userid", out JsonElement __userid)) return BadRequest();
                            if (!request.TryGetProperty("userName", out JsonElement __userName)) return BadRequest();
                            if (!request.TryGetProperty("userType", out JsonElement __userType)) return BadRequest();
                            string userSchool = school;
                            string _partition = $"HomeworkRecord-{__userid}";
                            if ($"{__userType}".Equals("student"))
                            {
                                request.TryGetProperty("userSchool", out JsonElement _userSchool);
                                userSchool = $"{_userSchool}";
                                _partition = $"HomeworkRecord-{_userSchool}-{__userid}";
                            }
                            if (!request.TryGetProperty("comment", out JsonElement _comment)) return BadRequest();
                            if (!request.TryGetProperty("star", out JsonElement _star)) return BadRequest();
                            double star = -1;
                            double.TryParse($"{_star}", out star);
                            HomeworkRecord record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<HomeworkRecord>($"{_id}", new PartitionKey(_partition));
                            ///话题对象，id为学生的作答记录的comid ,根据scope确定，  code 为Debate-{schoolId}，作业活动所在的学校编码|Debate-{teacherId}，作业活动所在的教师编码
                            string debateCode = "";
                            string debateTbname = "";
                            if (homework.scope.Equals("school"))
                            {
                                debateTbname = "School";
                                debateCode = $"Debate-{homework.school}";
                            }
                            else
                            {
                                debateTbname = "Teacher";
                                debateCode = $"Debate-{homework.creatorId}";
                            }
                            string userType = $"{_scope}".Equals("student") ? "student" : "tmdid";
                            string replyId = Guid.NewGuid().ToString();
                            DebateReply debateReply = new DebateReply
                            {
                                atUserType = $"{__userType}",
                                userType = userType,
                                id = replyId,
                                pid = $"{record.comid}",
                                tmdid = userid,
                                tmdname = name,
                                school = $"{userSchool}",
                                comment = $"{_comment}",
                                atTmdid = $"{__userid}",
                                atTmdname = $"{__userName}",
                                time = now
                            };
                            Debate debate = null;
                            try
                            {
                                debate = await client.GetContainer(Constant.TEAMModelOS, debateTbname).ReadItemAsync<Debate>($"{record.comid}", new PartitionKey(debateCode));
                                debate.replies.Add(debateReply);
                                await client.GetContainer(Constant.TEAMModelOS, debateTbname).ReplaceItemAsync<Debate>(debate, $"{record.comid}", new PartitionKey(debateCode));
                            }
                            catch (CosmosException ex)
                            {
                                debate = new Debate
                                {
                                    userType = $"{__userType}",
                                    comid = $"{homework.id}",
                                    code = debateCode,
                                    id = $"{record.comid}",
                                    tmdid = $"{__userid}",
                                    tmdname = $"{__userName}",
                                    title = $"{__userName}-{homework.name}",
                                    time = now,
                                    comment = "",
                                    school = homework.school,
                                    replies = new List<DebateReply>() { debateReply },
                                    source = "homework",
                                    openType = 0,
                                    ttl = -1,
                                    pk = "Debate"
                                };
                                await client.GetContainer(Constant.TEAMModelOS, debateTbname).CreateItemAsync<Debate>(debate, new PartitionKey(debateCode));
                            }
                            string identity = "student";
                            if (userid.Equals($"{homework.creatorId}"))
                            {
                                identity = "teacher";
                            }
                            HomeworkComment homeworkComment = record.comments.Find(x => x.userid.Equals(userid));
                            if (homeworkComment != null)
                            {
                                homeworkComment.star = star;
                                homeworkComment.replyIds=new List<string> { replyId };
                            }
                            else
                            {
                                homeworkComment = new HomeworkComment
                                {
                                    star = star,
                                    identity = identity,
                                    userType = $"{_scope}".Equals("student") ? "student" : "tmdid",
                                    userid = userid,
                                    username = name,
                                    school = school,
                                    replyIds = new List<string> { replyId }
                                };
                                record.comments.Add(homeworkComment);
                            }
                            if (!request.TryGetProperty("score", out JsonElement _score)) return BadRequest();
                            record.score = double.Parse($"{_score}");
                            await client.GetContainer(Constant.TEAMModelOS, tbname).ReplaceItemAsync<HomeworkRecord>(record, $"{_id}", new PartitionKey(_partition));
                            return Ok(new { status = true });
                        }
                        catch (CosmosException ex)
                        {
                            return Ok(new { error = 404 });
                        }
                        catch (Exception ex)
                        {
                            return BadRequest(new { error = 400 });
                        }
                }
            }
            catch (CosmosException ex)
            {

            }
            return Ok();
        }
        public class HomeworkReply
        {
            /// <summary>
            /// 角色类型  成员 student   学校 teacher
            /// </summary>
            public string roleType { get; set; }
            /// <summary>
            /// 某人对你这个能力点的学习评价的的评语记录的Id集合。
            /// </summary>
            public string reply { get; set; }
           
        }

        //    /// <summary>
        //    /// 撤消作业
        //    /// </summary>
        //    /// <param name="request"></param>
        //    /// <returns></returns>
        //    [ProducesDefaultResponseType]
        //    [HttpPost("cancel")]
        //    public async Task<IActionResult> Cancel(JsonElement requert)
        //    {
        //        /* if (!requert.TryGetProperty("id_token", out JsonElement id_token)) return BadRequest();
        //         //if (!requert.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
        //         var jwt = new JwtSecurityToken(id_token.GetString());
        //         if (!jwt.Payload.Iss.Equals("account.teammodel", StringComparison.Ordinal)) return BadRequest();
        //         var id = jwt.Payload.Sub;
        //         //var id = "03245d02-71ba-4e44-97dd-1e66c91bff6c";
        //         //if (!requert.TryGetProperty("id", out JsonElement id)) return BadRequest();
        //         var client = _azureCosmos.GetCosmosClient();
        //         //權限token
        //        *//* jwt.Payload.TryGetValue("name", out object name);
        //         jwt.Payload.TryGetValue("picture", out object picture);*//*
        //         var response = await client.GetContainer("TEAMModelOSTemp", "Teacher").ReadItemStreamAsync(id, new PartitionKey($"Homework-{id_token}"));
        //         if (response.Status == 200)
        //         {
        //             using var json = await JsonDocument.ParseAsync(response.ContentStream);
        //             int status = json.RootElement.GetProperty("status").GetInt32();
        //         }
        //         return Ok();*/
        //        ResponseBuilder builder = ResponseBuilder.custom();
        //        requert.TryGetProperty("id", out JsonElement homeWorkId);
        //        List<Homework> homeWorks = await _azureCosmos.FindByDict<Homework>(new Dictionary<string, object> { { "id", homeWorkId.ToString() } });

        //        foreach (Homework homeWork in homeWorks)
        //        {
        //            homeWork.status = 100;
        //        }
        //        List<Homework> homeWorks1 = await _azureCosmos.UpdateAll<Homework>(homeWorks);

        //        //查询之前是否有 关联关系表 HomeWorkStudent 有则删除
        //        List<HomeworkRecord> homeWorkStudents = await _azureCosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "id", homeWorkId.ToString() } });
        //        if (homeWorkStudents.IsNotEmpty())
        //        {

        //            //TODO 删除上传的文件
        //            await _azureCosmos.DeleteAll(homeWorkStudents);
        //        }
        //        //return builder.Data(homeWorks1).build();
        //        return Ok(homeWorks1);
        //    }

        //    /// <summary>
        //    /// 删除作业
        //    /// </summary>
        //    /// <param name="request"></param>
        //    /// <returns></returns>
        //    [ProducesDefaultResponseType]
        //    [HttpPost("delete")]
        //    public async Task<IActionResult> Delete(IdPk request)
        //    {
        //        //ResponseBuilder builder = ResponseBuilder.custom();
        //        //IdPk idPk = await _azureCosmos.DeleteAsync<Homework>(request);
        //        ////按作业id删除提交记录
        //        //List<HomeworkRecord> homeWorkStudents =  await _azureCosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "id", idPk.id } });
        //        ////TODO 删除上传的文件
        //        //await _azureCosmos.DeleteAll<HomeworkRecord>(homeWorkStudents);
        //        ////return builder.Data(idPk).build();
        //        //return Ok(idPk);
        //    }


        //    /// <summary>
        //    /// 新增或修改 作业活动 同时创建关联关系表
        //    /// </summary>
        //    /// <param name="request"></param>
        //    /// <returns></returns>
        //    [ProducesDefaultResponseType]
        //    [HttpPost("upsert")]
        //    public async Task<IActionResult> Upsert(HomeworkDto request)
        //    {
        //        ResponseBuilder builder = ResponseBuilder.custom();
        //        //新增
        //        var (id, name, picture, _) = HttpContext.GetAuthTokenInfo();
        //        if (string.IsNullOrEmpty(homework.homeWork.id))

        //        {
        //            homework.homeWork.code = "Homework-" + id;
        //            homework.homeWork.id = _snowflakeId.NextId()+"";
        //            homework.homeWork.status = 100;
        //            homework.reset = true;
        //            homework.homeWork.createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        //        }


        //        /*if (homework.homeWork.publishModel.Equals("0"))
        //        {
        //            homework.homeWork.startTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        //            homework.homeWork.status = 200;
        //        }
        //        else if (homework.homeWork.publishModel.Equals("1"))
        //        {
        //            //TimerWork<HomeWork>(homework.@params.homeWork.startTime,new Dictionary<string, object> { { "id", homework.@params.homeWork.id } });
        //            //设定开始时间
        //            string msgId = _snowflakeId.NextId() + "";
        //            long SequenceNumber =  await _serviceBus.GetServiceBusClient().SendLeamMessage<Homework>(Constants.TopicName, homework.homeWork.id, homework.homeWork.code, homework.homeWork.startTime,"going", msgId);
        //            homework.homeWork.sequenceNumber = SequenceNumber;

        //            //serviceBusReviceService.ReciveMessageAsync();
        //            //await _serviceBus.ReciveMessageAsync<Homework>(Constants.SubName);
        //            //_timerWorkService.TimerWork<Homework>(homework.@params.homeWork.startTime,200, new Dictionary<string, object> { { "id", homework.@params.homeWork.id } });
        //        }*/

        //        if (homework.homeWork.status == 0) {

        //            if (homework.homeWork.startTime < DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()) homework.homeWork.status = 200;
        //            else  homework.homeWork.status = 100;
        //        }

        //        Homework homeWork = await _azureCosmos.SaveOrUpdate<Homework>(homework.homeWork);

        //        //设定结束时间
        //        /*string msgEndId = _snowflakeId.NextId() + "";
        //        await _serviceBus.GetServiceBusClient().SendLeamMessage<Homework>(Constants.TopicName, homework.homeWork.id, homework.homeWork.code, homework.homeWork.endTime);*/
        //        //_timerWorkService.TimerWork<Homework>(homework.@params.homeWork.endTime, 300, new Dictionary<string, object> { { "id", homework.@params.homeWork.id } });
        //        //清除作业
        //        if (homework.reset)
        //        {
        //            //根据作业发布对象查找到每一个具体学生生成关联关系表 HomeWorkStudent
        //          //  List<Target> targets = homework.@params.homeWork.target;
        //            //List<HomeworkRecord> homeWorkStudents = new List<HomeworkRecord>();
        //           // foreach (Target target in targets)
        //           // {
        //                //查询之前是否有 关联关系表 HomeWorkStudent 有则删除
        //                List<HomeworkRecord> homeWorks = await _azureCosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "id", homework.homeWork.id } });
        //                if (homeWorks.IsNotEmpty())
        //                {
        //                    await _azureCosmos.DeleteAll(homeWorks);
        //                }
        //                //List<ClassStudent> classroom = await _cosmos.FindByDict<ClassStudent>(new Dictionary<string, object> { { "id", target.classroomCode }});
        //                //if (classroom.IsNotEmpty())
        //                //{

        //                //    foreach (ClassStudent student in classroom)
        //                //    {
        //                //        HomeworkRecord homeWorkStudent = new HomeworkRecord();
        //                //        homeWorkStudent.code = student.code;
        //                //        homeWorkStudent.id = homework.@params.homeWork.id;
        //                //        homeWorkStudent.classroom.code = target.classroomCode;
        //                //        homeWorkStudent.classroom.name = target.classroomName;
        //                //        homeWorkStudents.Add(homeWorkStudent);
        //                //    }

        //                //}
        //            //}
        //            //if (homeWorkStudents.IsNotEmpty())
        //            //{
        //            //    foreach (HomeworkRecord homeWorkStudents1 in homeWorkStudents)
        //            //    {
        //            //        List<Student> student = await _cosmos.FindById<Student>(homeWorkStudents1.code);//FindByDict<Student>(new Dictionary<string, object> { { "id", homeWorkStudents1.studentId } });
        //            //        if (student.IsNotEmpty())
        //            //        {

        //            //            homeWorkStudents1.code = student[0].studentId;
        //            //          //  homeWorkStudents1.nativeroom.code = student[0].classroomCode;
        //            //        }
        //            //    }
        //            //    await _cosmos.SaveOrUpdateAll<HomeworkRecord>(homeWorkStudents);
        //            //}
        //        }
        //        //return builder.Data(homeWork).build();
        //        return Ok(homeWork);
        //    }

        //    /// <summary>
        //    /// 新增或修改学生作业关联表
        //    /// </summary>
        //    /// <param name="request"></param>
        //    /// <returns></returns>
        //    [ProducesDefaultResponseType]
        //    [HttpPost("upsert-record")]
        //    public async Task<IActionResult> UpsertRecord(List<HomeworkRecord> request)
        //    {
        //        //ResponseBuilder builder = ResponseBuilder.custom();
        //        await _azureCosmos.SaveOrUpdateAll<HomeworkRecord>(request);
        //        //return builder.Data(request).build();
        //        return Ok(request);
        //    }

        //    /// <summary>
        //    /// 查询作业活动
        //    /// </summary>
        //    /// <param name="request"></param>
        //    /// <returns></returns>
        //    [ProducesDefaultResponseType]
        //    [HttpPost("find")]
        //    public async Task<IActionResult> Find(JsonElement request)
        //    {

        //        ResponseBuilder builder = ResponseBuilder.custom();
        //        List<Homework> data = new List<Homework>();
        //        List<HomeworkFindDto> homeWorkFindDtos = new List<HomeworkFindDto>();
        //        if (StringHelper.getKeyCount(request) > 0)
        //        {
        //            data = await _azureCosmos.FindByDict<Homework>(request);
        //            //判断作业提交信息
        //            if (data.IsNotEmpty())
        //            {
        //                foreach (Homework homeWork in data)
        //                {
        //                    //HomeworkFindDto homeWorkFindDto = new HomeworkFindDto();
        //                    List<string> pro = new List<string>();
        //                    pro.Add("submit");
        //                    List<HomeworkRecord> homeWorkStudents = await _azureCosmos.FindByDict<HomeworkRecord>(dict: new Dictionary<string, object> { { "id", homeWork.id } }, propertys: pro);
        //                    int sub = 0;
        //                    Dictionary<string, object> dict = new Dictionary<string, object>();
        //                    dict.Add("Sum", homeWorkStudents.Count);
        //                    dict.Add("Finish", sub);
        //                    HomeworkFindDto homeWorkFindDto = homeWork.ToJsonString().ToObject<HomeworkFindDto>();
        //                    homeWorkFindDto.statistics = dict;
        //                    homeWorkFindDtos.Add(homeWorkFindDto);
        //                }
        //            }
        //        }
        //        else
        //        {
        //            ///return builder.Error(ResponseCode.PARAMS_ERROR, "参数异常！").build();
        //            return Ok("参数异常！");
        //        }
        //        //return builder.Data(homeWorkFindDtos).Extend(new Dictionary<string, object> { { "count", data.Count } }).build();
        //        return Ok(new { homeWorkFindDtos, data.Count });
        //    }

        //    /// <summary>
        //    /// 查询作业学生关联
        //    /// </summary>
        //    /// <param name="request"></param>
        //    /// <returns></returns>
        //    [ProducesDefaultResponseType]
        //    [HttpPost("find-record")]
        //    public async Task<IActionResult> FindRecord(JsonElement requert)
        //    {
        //        var client = _azureCosmos.GetCosmosClient();
        //        //if (!requert.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
        //        //var (id, name, picture, _) = HttpContext.GetAuthTokenInfo();
        //        if (!requert.TryGetProperty("id_token", out JsonElement id_token)) return BadRequest();
        //        var jwt = new JwtSecurityToken(id_token.GetString());
        //        if (!jwt.Payload.Iss.Equals("account.teammodel", StringComparison.Ordinal)) return BadRequest();
        //        var id = jwt.Payload.Sub;

        //        List<object> records = new List<object>();
        //        var query = $"select c.id,c.classroom,c.submit, c.submitTime,c.score,c.content,c.stuCmt,c.tchCmt from c where id = {id}";
        //        await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Student").GetItemQueryStreamIterator(queryText: query, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"HomeworkRecord-{id}") }))
        //        {
        //            using var json = await JsonDocument.ParseAsync(item.ContentStream);

        //            if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
        //            {
        //                foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
        //                {
        //                    records.Add(obj.ToObject<object>());
        //                }
        //            }
        //        }

        //        return Ok(new { records });
        //        /*ResponseBuilder builder = ResponseBuilder.custom();
        //        List<HomeworkRecord> data = new List<HomeworkRecord>();

        //        if (StringHelper.getKeyCount(request) > 0)
        //        {
        //            data = await _azureCosmos.FindByDict<HomeworkRecord>(request);
        //        }
        //        else
        //        {
        //            return builder.Error(ResponseCode.PARAMS_ERROR, "参数异常！").build();
        //        }
        //        return builder.Data(data).Extend(new Dictionary<string, object> { { "count", data.Count } }).build();*/
        //    }




        //    /// <summary>
        //    /// 教师作业打分评论
        //    /// </summary>
        //    /// <param name="request"></param>
        //    /// <returns></returns>
        //    [ProducesDefaultResponseType]
        //    [HttpPost("tch-score")]
        //    public async Task<IActionResult> TchScore(HomeworkScoringDto request)
        //    {
        //        ResponseBuilder builder = ResponseBuilder.custom();
        //        List<HomeworkRecord> homeWorkStudents = await _azureCosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "code", homework.studentId }, { "id", homework.homeWorkId } });
        //        HomeworkRecord data = new HomeworkRecord();
        //        if (homeWorkStudents.IsNotEmpty())
        //        {

        //            homeWorkStudents[0].score = homework.score ?? homeWorkStudents[0].score;
        //            HomeWorkComment homeWorkComment = new HomeWorkComment
        //            {
        //                comment = homework.comments,
        //                createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
        //                TEAMModelId = homework.TEAMModelId
        //            };

        //            homeWorkStudents[0].tchCmt = homeWorkComment;
        //            data = await _azureCosmos.SaveOrUpdate(homeWorkStudents[0]);
        //        }
        //        //return builder.Data(data).build();
        //        return Ok(data);
        //    }



        //    /// <summary>
        //    /// 学生作业打分评论
        //    /// </summary>
        //    /// <param name="request"></param>
        //    /// <returns></returns>
        //    [ProducesDefaultResponseType]
        //    [HttpPost("stu-score")]
        //    public async Task<IActionResult> StuScore(HomeworkCommentDto request)
        //    {
        //        ResponseBuilder builder = ResponseBuilder.custom();
        //        List<HomeworkRecord> homeWorkStudents = await _azureCosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "code", homework.studentId }, { "id", homework.homeWorkId } });
        //        List<Homework> homeWorks = await _azureCosmos.FindByDict<Homework>(new Dictionary<string, object> { { "id", homework.homeWorkId } });
        //        HomeworkRecord data = new HomeworkRecord();
        //        if (homeWorks.IsNotEmpty() && homeWorks[0].other.Contains("comment"))
        //        {
        //            if (homeWorkStudents.IsNotEmpty())
        //            {
        //                if (string.IsNullOrEmpty(homework.commentid))
        //                {
        //                    //评论
        //                    StudentComment homeWorkComment = new StudentComment
        //                    {
        //                        commentid = _snowflakeId.NextId() + "",
        //                        comment = homework.comment,
        //                        createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
        //                        fromId = homework.fromId,
        //                        score = homework.score
        //                    };


        //                    homeWorkStudents[0].stuCmt.Add(homeWorkComment);
        //                }
        //                else
        //                {
        //                    //回复评论
        //                    foreach (StudentComment comment in homeWorkStudents[0].stuCmt)
        //                    {
        //                        if (comment.commentid == homework.commentid)
        //                        {
        //                            Reply reply = new Reply();
        //                            reply.fromId = homework.fromId;
        //                            reply.toId = homework.toId;
        //                            reply.identity = homework.identity;
        //                            reply.comment = homework.comment;
        //                            reply.createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        //                            comment.reply.Add(reply);
        //                        }
        //                    }
        //                }
        //                data = await _azureCosmos.Update(homeWorkStudents[0]);
        //            }
        //            //return builder.Data(data).build();
        //            return Ok(data);
        //        }
        //        else {
        //            //return builder.Error(ResponseCode.FAILED, "未开放互评！").build();
        //            return Ok("未开放互评！");
        //        } 
        //    }
    }
}