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;
using Microsoft.AspNetCore.Authorization;

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;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        public IConfiguration _configuration { get; set; }
        public HomeworkController(CoreAPIHttpService coreAPIHttpService, 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")]
        [Authorize(Roles = "IES")]
        [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;
                if (homework.startTime <= 0)
                {
                    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")]
        [Authorize(Roles = "IES")]
        [AuthToken(Roles = "teacher,admin,student")]
        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]
        [Authorize(Roles = "IES")]
        [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")]
        [Authorize(Roles = "IES")]
        [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>();
            public List<Attachment> content { get; set; } = new List<Attachment>();
        }
        /// <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("Standard", out object standard)) return BadRequest();
            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)|| $"{_targetType}".Equals("yxtrain", 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<RMember> tmdinfos, List<RGroupList> classInfo) = await GroupListService.GetStutmdidListids(_coreAPIHttpService,client, _dingDing, listIds, homework.school);
                            var addStudentsCls = tmdinfos.FindAll(x => x.type == 2);
                            var addTmdidsCls = tmdinfos.FindAll(x => x.type == 1);
                            if ($"{_targetType}".Equals("research", StringComparison.OrdinalIgnoreCase) || $"{_targetType}".Equals("yxtrain", StringComparison.OrdinalIgnoreCase))
                            {


                                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 {
                                if (addTmdidsCls.IsNotEmpty())
                                {
                                    addTmdidsCls.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() });
                                    });
                                }
                                if (addStudentsCls.IsNotEmpty())
                                {
                                    addStudentsCls.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 = "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.content = record.content;
                                    // 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)
                        {
                            bool falge = true;
                            if (homework.leaderSubmit == 1 && content.Exists(x => x.prime == true))
                            {
                                List<RGroupList> yxtrain = await GroupListService.GetGroupListMemberByType(_coreAPIHttpService,client, "yxtrain", new List<string> { "school" }, $"{school}", _dingDing);
                                var members = yxtrain.SelectMany(x => x.members).ToList();
                                var leader = members.Find(x => x.tag!=null && x.id.Equals(userid)  && x.tag.Equals("leader"));
                                if (leader != null && !string.IsNullOrEmpty(leader.groupName))
                                {
                                    falge = false;
                                    var our = members.ToList().FindAll(x =>x.groupName!=null && x.groupName.Equals(leader.groupName));
                                    foreach (var one in our) {
                                        string pk = $"HomeworkRecord-{one.id}";
                                        try
                                        {
                                            HomeworkRecord record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<HomeworkRecord>($"{_id}", new PartitionKey(pk));
                                            record.content = content;
                                            record.answer = $"{_answer}";
                                            record.submitCount += 1;
                                            record.time = now;
                                            await client.GetContainer(Constant.TEAMModelOS, tbname).ReplaceItemAsync<HomeworkRecord>(record, $"{_id}", new PartitionKey(pk));
                                            taskStatus = 1;
                                            msgid = 1;
                                        }
                                        catch (CosmosException ex)
                                        {
                                            if (ex.Status == 404)
                                            {
                                                HomeworkRecord record = new HomeworkRecord
                                                {
                                                    teacher = $"{teacher}",
                                                    school = school,
                                                    id = $"{_id}",
                                                    code = pk,
                                                    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(pk));
                                                taskStatus = 1;
                                                msgid = 1;
                                            }
                                        }
                                        //TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO 写入方便教师查看的作答记录
                                        try
                                        {
                                            StuActivity activity = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").ReadItemAsync<StuActivity>($"{_id}", new PartitionKey($"Activity-{one.id}"));
                                            activity.taskStatus = taskStatus;
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync<StuActivity>(activity, $"{_id}", new PartitionKey($"Activity-{one.id}"));
                                        }
                                        catch (CosmosException ex)
                                        {
                                           
                                        }
                                        await StatisticsService.SendServiceBus( ($"{standard}", new List<string> { $"{one.id}" }, $"{school}", new List<string>() { StatisticsService.OfflineRecord },0)  , _configuration, _serviceBus, client);
                                        
                                    }
                                }
                            }

                            if (falge) {
                                try
                                {
                                    HomeworkRecord record = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<HomeworkRecord>($"{_id}", new PartitionKey(partitionKey));
                                    record.content = content;
                                    record.answer = $"{_answer}";
                                    record.submitCount += 1;
                                    record.time = now;
                                    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;
                                }
                                if (content.Exists(x => x.prime == true))
                                {
                                    await StatisticsService.SendServiceBus(   ($"{standard}", new List<string> { $"{userid}" }, $"{school}", new List<string>() { StatisticsService.OfflineRecord }, 0 ), _configuration, _serviceBus, client);
                                }
                            }
                            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.FindAll(y => y.identity.Equals("student")).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();
                            if (!request.TryGetProperty("identity", out JsonElement __identity)) 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 = $"{__identity}";
                            if (string.IsNullOrEmpty(identity))
                            {
                                identity = "student";
                            }
                            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();
                            if (!request.TryGetProperty("identity", out JsonElement __identity)) 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 = $"{__identity}";
                            if (string.IsNullOrEmpty(identity))
                            {
                                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; }
           
        }
         
    }
}