TEAMModelOS/TEAMModelOS/Controllers/Common/ActivityController.cs

using Azure.Cosmos;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using Azure;
using Microsoft.Extensions.Configuration;
using TEAMModelOS.Filter;
using HTEXLib.COMM.Helpers;
using TEAMModelOS.SDK;
using StackExchange.Redis;
using System.IdentityModel.Tokens.Jwt;
using Microsoft.AspNetCore.Routing;
using Pipelines.Sockets.Unofficial.Arenas;
using static TEAMModelOS.SDK.CoreAPIHttpService;
using System.Net;
using TEAMModelOS.SDK.Models.Service;
using TEAMModelOS.Services;
using Azure.Storage.Sas;
using Microsoft.IdentityModel.Tokens;
using System.Net.Http;
using IHttpClientFactory = System.Net.Http.IHttpClientFactory;
using SDK.Helpers;
using Microsoft.Azure.Amqp.Framing;
using Microsoft.AspNetCore.Authorization;
using DocumentFormat.OpenXml.Drawing.Charts;
using static SKIT.FlurlHttpClient.Wechat.TenpayV3.Models.CreateApplyForSubjectApplymentRequest.Types;
using static TEAMModelOS.Controllers.FixDataController;
using DocumentFormat.OpenXml.Spreadsheet;
using DocumentFormat.OpenXml.Office2013.Drawing.ChartStyle;
using static TEAMModelOS.SDK.Models.Cosmos.Student.StudentAnalysis;
using System.Net.NetworkInformation;
namespace TEAMModelOS.Controllers
{


    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]

    [Route("activity")]
    [ApiController]
    public class ActivityController : ControllerBase
    {
        private AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        private readonly Option _option;
        private readonly AzureServiceBusFactory _serviceBus;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly HttpTrigger _httpTrigger;
        private readonly IPSearcher _searcher;
        public IConfiguration _configuration { get; set; }
        private IHttpClientFactory _httpClientFactory;
        public ActivityController(AzureRedisFactory azureRedis, AzureCosmosFactory azureCosmos, DingDing dingDing, IOptionsSnapshot<Option> option, CoreAPIHttpService coreAPIHttpService, AzureServiceBusFactory serviceBus, AzureStorageFactory azureStorage, IConfiguration configuration, HttpTrigger httpTrigger, IPSearcher searcher, IHttpClientFactory httpClientFactory)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _option = option?.Value;
            _serviceBus = serviceBus;
            _configuration = configuration;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
            _coreAPIHttpService = coreAPIHttpService;
            _httpTrigger=httpTrigger;
            _searcher=searcher;
            _httpClientFactory=httpClientFactory;
        }

        /// <summary>
        /// 分站管理
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin,area")]
        [HttpPost("website-manage")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif
        public async Task<IActionResult> WebsiteManage(JsonElement request)
        {
            (string tmdid, _, _, string school) = HttpContext.GetAuthTokenInfo();
            if (!request.TryGetProperty("grant_type", out JsonElement grant_type)) return BadRequest();
            {
                switch (true)
                {
                    case bool when $"{grant_type}".Equals("update", StringComparison.OrdinalIgnoreCase):
                        {
                            request.TryGetProperty("areaId", out JsonElement _areaId);
                            if (!request.TryGetProperty("website", out JsonElement _website)) return BadRequest();
                            ActivityWebsite website = _website.ToObject<ActivityWebsite>();
                            Azure.Response teammodelResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(website.id, new PartitionKey("ActivityWebsite"));
                            if (teammodelResponse.Status == 200)
                            {
                                ActivityWebsite activityWebsite = JsonDocument.Parse(teammodelResponse.Content).RootElement.ToObject<ActivityWebsite>();
                                website.route=activityWebsite.route;
                                website.pk=activityWebsite.pk;
                                website.code=activityWebsite.code;
                                website.scope=activityWebsite.scope;
                                //不是醍摩豆学区的，不能修改是否有公开办活动权限
                                if (!(string.IsNullOrWhiteSpace($"{_areaId}")&&  _areaId.Equals("02944f32-f534-3397-ea56-e6f1fc6c3714")))
                                {
                                    website.allowPublic=activityWebsite.allowPublic;
                                }
                            }
                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).UpsertItemAsync(website, new PartitionKey("ActivityWebsite"));

                            return Ok(new { website, code = 200 });
                        }
                    case bool when $"{grant_type}".Equals("list", StringComparison.OrdinalIgnoreCase):
                        {
                            List<ActivityWebsite> websites = new List<ActivityWebsite>();
                            if (!request.TryGetProperty("websiteId", out JsonElement _websiteId)) return BadRequest();
                            string websiteId = _websiteId.GetString();
                            if (websiteId.Equals("02944f32-f534-3397-ea56-e6f1fc6c3714", StringComparison.OrdinalIgnoreCase))
                            {
                                Azure.Response teammodelResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync("teammodel", new PartitionKey("ActivityWebsite"));
                                if (teammodelResponse.Status == 200)
                                {
                                    ActivityWebsite activityWebsite = JsonDocument.Parse(teammodelResponse.Content).RootElement.ToObject<ActivityWebsite>();
                                    websites.Add(activityWebsite);
                                }
                                else
                                {
                                    ActivityWebsite website = new ActivityWebsite
                                    {
                                        id="teammodel",
                                        pk="ActivityWebsite",
                                        code="ActivityWebsite",
                                        route="teammodel",
                                        scope="public",
                                        allowPublic=1,
                                    };
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).UpsertItemAsync(website, new PartitionKey(website.code));
                                    websites.Add(website);
                                }
                                //返回其他区的。
                                string sqlArea = "select value c from c ";
                                var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).GetList<Area>(sqlArea, "Base-Area");
                                if (result.list.IsNotEmpty())
                                {
                                    string sqlWebsite = $"select value c from c where c.id in ({string.Join(",", result.list.Select(z => $"'{z.id}'"))})";
                                    var resultWebsite = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).GetList<ActivityWebsite>(sqlWebsite, "ActivityWebsite");
                                    foreach (var item in result.list)
                                    {
                                        var website = resultWebsite.list.Find(z => z.id.Equals(item.id));
                                        if (website!=null)
                                        {
                                            if (!string.IsNullOrWhiteSpace(item.shortCode))
                                            {
                                                bool change = false;
                                                if (string.IsNullOrWhiteSpace(website.route))
                                                {
                                                    website.route=item.shortCode;
                                                    change = true;
                                                }
                                                else
                                                {
                                                    if (!website.route.Equals(item.shortCode))
                                                    {
                                                        website.route=item.shortCode;
                                                        change = true;
                                                    }
                                                }
                                                if (change)
                                                {
                                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).UpsertItemAsync(website, new PartitionKey(website.code));
                                                }
                                            }
                                        }
                                        else
                                        {
                                            website= new ActivityWebsite
                                            {
                                                id= item.id,
                                                code="ActivityWebsite",
                                                pk="ActivityWebsite",
                                                route=item.shortCode,
                                                scope="area",
                                                allowPublic=0,
                                            };
                                        }
                                        websites.Add(website);
                                    }
                                }
                            }
                            else
                            {
                                Azure.Response activityWebsiteResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(websiteId, new PartitionKey("ActivityWebsite"));
                                if (activityWebsiteResponse.Status == 200)
                                {
                                    ActivityWebsite activityWebsite = JsonDocument.Parse(activityWebsiteResponse.Content).RootElement.ToObject<ActivityWebsite>();
                                    Area area = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemAsync<Area>(websiteId, new PartitionKey("Base-Area"));
                                    if (!string.IsNullOrWhiteSpace(area.shortCode))
                                    {
                                        bool change = false;
                                        if (string.IsNullOrWhiteSpace(activityWebsite.route))
                                        {
                                            activityWebsite.route=area.shortCode;
                                            change = true;
                                        }
                                        else
                                        {
                                            if (!activityWebsite.route.Equals(area.shortCode))
                                            {
                                                activityWebsite.route=area.shortCode;
                                                change = true;
                                            }
                                        }
                                        if (change)
                                        {
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).UpsertItemAsync(activityWebsite, new PartitionKey(activityWebsite.code));
                                        }
                                    }
                                    websites.Add(activityWebsite);
                                }
                                else
                                {
                                    string route = string.Empty;
                                    string scope = string.Empty;
                                    Azure.Response responseArea = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(websiteId, new PartitionKey("Base-Area"));
                                    if (responseArea.Status==200)
                                    {
                                        Area area = JsonDocument.Parse(responseArea.Content).RootElement.ToObject<Area>();
                                        if (!string.IsNullOrWhiteSpace(area.shortCode))
                                        {
                                            route=area.shortCode;
                                        }
                                        scope="area";
                                    }
                                    if (!string.IsNullOrWhiteSpace(scope))
                                    {
                                        Azure.Response responseSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync(websiteId, new PartitionKey("Base"));
                                        if (responseSchool.Status==200)
                                        {
                                            scope="school";
                                            route = websiteId;
                                        }
                                    }
                                    if (!string.IsNullOrWhiteSpace(scope))
                                    {
                                        if (!string.IsNullOrWhiteSpace(route))
                                        {
                                            ActivityWebsite website = new ActivityWebsite
                                            {
                                                id=websiteId,
                                                pk="ActivityWebsite",
                                                code="ActivityWebsite",
                                                route=route,
                                                scope=scope,
                                                allowPublic=0
                                            };
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).UpsertItemAsync(website, new PartitionKey(website.code));
                                            websites.Add(website);
                                        }
                                        else
                                        {
                                            ActivityWebsite website = new ActivityWebsite
                                            {
                                                id=websiteId,
                                                pk="ActivityWebsite",
                                                code="ActivityWebsite",
                                                route=route,
                                                scope=scope,
                                                allowPublic=0
                                            };
                                            websites.Add(website);
                                        }
                                    }
                                }
                            }
                            return Ok(new { code = 200, websites });
                        }
                }
            }
            return Ok();
        }

        /// <summary>
        /// 添加活动参与对象，学校，教师
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin,area")]
        [HttpPost("invite-target")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif

        public async Task<IActionResult> InviteTarget(JsonElement request)
        {
            (string tmdid, _, _, string school) = HttpContext.GetAuthTokenInfo();
            if (!request.TryGetProperty("grant_type", out JsonElement grant_type)) return BadRequest();
            switch (true)
            {
                case bool when $"{grant_type}".Equals("schools", StringComparison.OrdinalIgnoreCase):
                    {
                        if (!request.TryGetProperty("scope", out JsonElement _scope)) return BadRequest();
                        if (!request.TryGetProperty("areaId", out JsonElement _areaId)) return BadRequest();
                        string sql = string.Empty;
                        int allowPublic = 0;
                        if (_scope.GetString().Equals("public", StringComparison.OrdinalIgnoreCase))
                        {
                            if (_areaId.GetString().Equals("02944f32-f534-3397-ea56-e6f1fc6c3714"))
                            {
                                allowPublic=1;
                            }
                            else
                            {
                                Azure.Response activityWebsiteResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(_areaId.GetString(), new PartitionKey("ActivityWebsite"));
                                if (activityWebsiteResponse.Status==200)
                                {
                                    ActivityWebsite website = JsonDocument.Parse(activityWebsiteResponse.Content).RootElement.ToObject<ActivityWebsite>();
                                    allowPublic=website.allowPublic;
                                }
                            }
                        }
                        if (allowPublic==1)
                        {
                            sql = "select c.id,c.name ,c.picture,c.region,c.province,c.city,c.areaId   from c where c.code='Base' ";
                        }
                        else
                        {
                            sql = $"select c.id,c.name ,c.picture,c.region,c.province,c.city,c.areaId   from c where c.code='Base' and c.areaId='{_areaId}' ";
                        }
                        var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<School>(sql, "Base");
                        var sc = result.list.FindAll(z => !string.IsNullOrWhiteSpace(z.areaId));
                        List<dynamic> schools = new List<dynamic>();
                        if (sc.IsNotEmpty())
                        {
                            string areaSql = $"select value c from c where c.id in ({string.Join(",", sc.Select(z => $"'{z.areaId}'").ToHashSet())})";
                            var areaResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).GetList<Area>(areaSql, "Base-Area");
                            if (areaResult.list.IsNotEmpty())
                            {

                                foreach (var item in result.list)
                                {
                                    if (!string.IsNullOrWhiteSpace(item.areaId))
                                    {
                                        var area = areaResult.list.Find(z => z.id.Equals(item.areaId));
                                        schools.Add(new { item.id, item.name, item.picture, item.region, item.province, item.city, item.areaId, areaName = area?.name });
                                    }
                                    else
                                    {
                                        schools.Add(new { item.id, item.name, item.picture, item.region, item.province, item.city, item.areaId, areaName = string.Empty });
                                    }
                                }
                            }
                        }
                        return Ok(new { code = 200, schools });
                    }
                case bool when $"{grant_type}".Equals("teachers", StringComparison.OrdinalIgnoreCase):
                    {
                        if (!string.IsNullOrWhiteSpace(school))
                        {
                            School schoolbase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                            string sql = $"select c.id,c.name ,c.picture   from c where c.code='Teacher-{school}' ";
                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<SchoolTeacher>(sql, $"Teacher-{school}");
                            return Ok(new { code = 200, teachers = result.list.Select(z => new { z.id, z.name, z.picture, school, schooName = schoolbase.name }) });
                        }
                        else
                        {
                            return Ok(new { code = 1, msg = "没有学校信息" });
                        }
                    }
            }
            return Ok(new { code = 400 });
        }

        /// <summary>
        /// 管理
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "teacher,admin,area,expert")]
        [HttpPost("manage")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif

        public async Task<IActionResult> Manage(JsonElement request)
        {
            try
            {
                (string tmdid, _, _, string school) = HttpContext.GetAuthTokenInfo();
                if (!request.TryGetProperty("grant_type", out JsonElement grant_type)) return BadRequest();
                var client = _azureCosmos.GetCosmosClient();
                switch (true)
                {
                    //修改赛课活动信息
                    case bool when $"{grant_type}".Equals("update-contest-base", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("contestUpdate", out JsonElement _contestUpdate)) return BadRequest();
                            Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                            if (responseContest.Status==200)
                            {
                                Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                ContestUpdate contestUpdate = new ContestUpdate() {
                                    signStime= contest.sign?.stime,
                                    signEtime= contest.sign?.etime,

                                    uploadStime= contest.upload?.stime,
                                    uploadEtime= contest.upload?.etime,

                                    reviewStime= contest.review?.stime,
                                    reviewEtime= contest.review?.etime,

                                    scoreStime= contest.score?.stime,
                                    scoreEtime= contest.score?.etime,
                                };


                                if (_contestUpdate.TryGetProperty("signStime", out JsonElement signStime)  && signStime.ValueKind.Equals(JsonValueKind.Number)) {
                                    contestUpdate.signStime=signStime.GetInt64();
                                }
                                if (_contestUpdate.TryGetProperty("signEtime", out JsonElement signEtime)  && signEtime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    contestUpdate.signEtime=signEtime.GetInt64();
                                }

                                if (_contestUpdate.TryGetProperty("uploadStime", out JsonElement uploadStime)  && uploadStime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    contestUpdate.uploadStime=uploadStime.GetInt64();
                                }
                                if (_contestUpdate.TryGetProperty("uploadEtime", out JsonElement uploadEtime)  && uploadEtime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    contestUpdate.uploadEtime=uploadEtime.GetInt64();
                                }

                                if (_contestUpdate.TryGetProperty("reviewStime", out JsonElement reviewStime)  && reviewStime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    contestUpdate.reviewStime=reviewStime.GetInt64();
                                }

                                if (_contestUpdate.TryGetProperty("reviewEtime", out JsonElement reviewEtime)  && reviewEtime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    contestUpdate.reviewEtime=reviewEtime.GetInt64();
                                }

                                if (_contestUpdate.TryGetProperty("scoreStime", out JsonElement scoreStime)  && scoreStime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    contestUpdate.scoreStime=scoreStime.GetInt64();
                                }

                                if (_contestUpdate.TryGetProperty("scoreEtime", out JsonElement scoreEtime)  && scoreEtime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    contestUpdate.scoreEtime=scoreEtime.GetInt64();
                                }
                                if (_contestUpdate.TryGetProperty("addModules", out JsonElement addModules)  && addModules.ValueKind.Equals(JsonValueKind.Array))
                                {
                                    contestUpdate.addModules = addModules.ToObject<List<string>>();
                                }
                                if (contest.modules.Contains("sign")  && contest.sign!= null    )
                                {

                                    if (contestUpdate.signStime.HasValue  &&contestUpdate.signEtime.HasValue) {
                                        if (contestUpdate.reviewStime.HasValue)
                                        {
                                            if (contestUpdate.signEtime.Value<contestUpdate.reviewStime.Value)
                                            {
                                                contest.sign.etime=contestUpdate.signEtime.Value;
                                            }
                                            else
                                            {
                                                return Ok(new { code = 1, msg = "报名结束时间不能晚于评审开始时间！" });
                                            }
                                        }
                                        else
                                        {
                                            contest.sign.etime=contestUpdate.signEtime.Value;
                                        }
                                        if (contestUpdate.signEtime.Value> contestUpdate.signStime.Value)
                                        {
                                            contest.sign.stime=contestUpdate.signStime.Value;
                                        }
                                        else {
                                            return Ok(new { code = 2, msg = "报名开始时间不能早于报名结束时间！" });
                                        }
                                    }
                                    if (_contestUpdate.TryGetProperty("limit", out JsonElement limit)  && limit.ValueKind.Equals(JsonValueKind.Number))
                                    {
                                        contest.sign.limit=limit.GetInt32();
                                    }
                                }

                                if (contest.modules.Contains("upload")  && contest.upload!= null)
                                {

                                    if (contestUpdate.uploadStime.HasValue  &&contestUpdate.uploadEtime.HasValue)
                                    {
                                        if (contestUpdate.reviewStime.HasValue)
                                        {
                                            if (contestUpdate.uploadEtime.Value<contestUpdate.reviewStime.Value)
                                            {
                                                contest.upload.etime=contestUpdate.uploadEtime.Value;
                                            }
                                            else
                                            {
                                                return Ok(new { code =3, msg = "报名结束时间不能晚于评审开始时间！" });
                                            }
                                        }
                                        else
                                        {
                                            contest.upload.etime=contestUpdate.uploadEtime.Value;
                                        }
                                        if (contestUpdate.uploadEtime.Value> contestUpdate.uploadStime.Value)
                                        {
                                            contest.upload.stime=contestUpdate.uploadStime.Value;
                                        }
                                        else
                                        {
                                            return Ok(new { code = 4, msg = "报名开始时间不能早于报名结束时间！" });
                                        }
                                    }
                                    if (_contestUpdate.TryGetProperty("updateDesc", out JsonElement desc)  && desc.ValueKind.Equals(JsonValueKind.String))
                                    {
                                        contest.upload.desc=desc.GetString();

                                    }
                                    if (_contestUpdate.TryGetProperty("fileType", out JsonElement fileType)  && fileType.ValueKind.Equals(JsonValueKind.Array))
                                    {
                                        if (contest.upload.fileType.IsNotEmpty())
                                        {
                                            contest.upload.fileType=fileType.ToObject<List<string>>();
                                        }
                                    }
                                }

                                if (contest.modules.Contains("review")  && contest.review!= null)
                                {

                                    if (contestUpdate.reviewStime.HasValue  &&contestUpdate.reviewEtime.HasValue)
                                    {
                                        if (contestUpdate.scoreStime.HasValue)
                                        {
                                            if (contestUpdate.reviewEtime.Value<contestUpdate.scoreStime.Value)
                                            {
                                                contest.review.etime=contestUpdate.reviewEtime.Value;
                                            }
                                            else
                                            {
                                                return Ok(new { code = 5, msg = "评审结束时间不能晚于成绩公布开始时间！" });
                                            }
                                        }
                                        else
                                        {
                                            contest.review.etime=contestUpdate.reviewEtime.Value;
                                        }
                                        if (contestUpdate.reviewEtime.Value> contestUpdate.reviewStime.Value)
                                        {
                                            contest.review.stime=contestUpdate.reviewStime.Value;
                                        }
                                        else
                                        {
                                            return Ok(new { code = 6, msg = "评审开始时间不能早于评审结束时间！" });
                                        }
                                    }
                                }

                                if (contest.modules.Contains("score")  && contest.score!= null)
                                {

                                    if (contestUpdate.scoreStime.HasValue  &&contestUpdate.scoreEtime.HasValue)
                                    {
                                        if (contestUpdate.reviewEtime.HasValue)
                                        {
                                            if (contestUpdate.reviewEtime.Value<contestUpdate.scoreStime.Value)
                                            {
                                                contest.score.stime=contestUpdate.scoreStime.Value;
                                            }
                                            else
                                            {
                                                return Ok(new { code = 7, msg = "成绩公布开始时间不能早于评审结束时间！" });
                                            }
                                        }
                                        else
                                        {
                                            contest.score.stime=contestUpdate.scoreStime.Value;
                                        }
                                        if (contestUpdate.scoreEtime.Value> contestUpdate.scoreStime.Value)
                                        {
                                            contest.score.etime=contestUpdate.scoreEtime.Value;
                                        }
                                        else
                                        {
                                            return Ok(new { code = 8, msg = "成绩公布结束时间不能晚于成绩公布开始时间！" });
                                        }
                                    }
                                }
                                else {
                                    //增加公示成绩模块
                                    if (contestUpdate.addModules.Contains("score") ) 
                                    {
                                        if (contestUpdate.scoreStime.HasValue  &&contestUpdate.scoreEtime.HasValue) 
                                        {
                                            if (!contest.modules.Contains("score"))
                                            {
                                                contest.modules.Add("score");
                                            }
                                            if (contest.score==null)
                                            {
                                                contest.score= new ContestScore
                                                {
                                                    scoreStatus=0,
                                                    showType=0,
                                                    showDetail=0,
                                                    levelType=0,
                                                    top=-1
                                                };
                                            }
                                            if (contestUpdate.reviewEtime.HasValue)
                                            {
                                                if (contestUpdate.reviewEtime.Value<contestUpdate.scoreStime.Value)
                                                {
                                                    contest.score.stime=contestUpdate.scoreStime.Value;
                                                }
                                                else
                                                {
                                                    return Ok(new { code = 7, msg = "成绩公布开始时间不能早于评审结束时间！" });
                                                }
                                            }
                                            else
                                            {
                                                contest.score.stime=contestUpdate.scoreStime.Value;
                                            }
                                            if (contestUpdate.scoreEtime.Value> contestUpdate.scoreStime.Value)
                                            {
                                                contest.score.etime=contestUpdate.scoreEtime.Value;
                                            }
                                            else
                                            {
                                                return Ok(new { code = 8, msg = "成绩公布结束时间不能晚于成绩公布开始时间！" });
                                            }
                                        }
                                    }
                                }

                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(contest, new PartitionKey("Contest"));
                                return Ok(new { code = 200, contest });
                            }
                            else
                            {
                                return Ok(new { code = 9, msg = "赛课模块信息未完善！" });
                            }
                        }
                    //修改活动基本信息
                    case bool when $"{grant_type}".Equals("update-activity-base", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("activityUpdate", out JsonElement _activityUpdate)) return BadRequest();
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
                            if (response.Status==200)
                            {
                                Activity activity = JsonDocument.Parse(response.Content).RootElement.ToObject<Activity>();

                                _activityUpdate.CopyToSameProperty<ActivityUpdate, Activity>(activity,
                                    filter: new List<string>() { "name", "subject", "description", "address", "stime", "etime", "poster", "attachment", "zb", "cb", "mzsm" });
                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(activity, new PartitionKey("Activity"));
                                return Ok(new { activity, code = 200 });
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "活动不存在！" });
                            }
                        }
                    //创建活动
                    case bool when $"{grant_type}".Equals("create", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("Activity", out JsonElement _activity)) return Ok(new { code = 1, msg = "活动信息参数错误" });
                            Activity activity = _activity.ToObject<Activity>();
                            activity.id=!string.IsNullOrWhiteSpace(activity.id) ? activity.id : Guid.NewGuid().ToString();
                            activity.code="Activity";
                            activity.pk="Activity";
                            //如果是区级活动，enroll报名制,则学校的确认状态默认为1 。
                            //if (activity.scope.Equals("area", StringComparison.OrdinalIgnoreCase) && activity.joinMode.Equals("enroll", StringComparison.OrdinalIgnoreCase)) 
                            //{
                            //    activity.schools.ForEach(z => z.status=1);
                            //}
                            ActivityWebsite website = null;
                            {
                                string websiteId = activity.owner;
                                string route = string.Empty;
                                if (activity.owner.Equals("02944f32-f534-3397-ea56-e6f1fc6c3714", StringComparison.OrdinalIgnoreCase)  && activity.scope.Equals("public", StringComparison.OrdinalIgnoreCase))
                                {
                                    websiteId="teammodel";
                                    route="teammodel";
                                }

                                Azure.Response activityWebsiteResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(websiteId, new PartitionKey("ActivityWebsite"));
                                if (activityWebsiteResponse.Status!=200)
                                {
                                    if (activity.scope.Equals("area", StringComparison.OrdinalIgnoreCase))
                                    {
                                        Area area = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemAsync<Area>(activity.owner, new PartitionKey("Base-Area"));
                                        if (!string.IsNullOrWhiteSpace(area.shortCode))
                                        {
                                            route=area.shortCode;
                                        }
                                    }
                                    if (activity.scope.Equals("school", StringComparison.OrdinalIgnoreCase))
                                    {
                                        route=activity.owner;
                                    }
                                    if (!string.IsNullOrWhiteSpace(route))
                                    {
                                        website = new ActivityWebsite
                                        {
                                            id=websiteId,
                                            pk="ActivityWebsite",
                                            code="ActivityWebsite",
                                            route=route,
                                            scope=activity.scope,
                                        };
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).UpsertItemAsync(website, new PartitionKey(website.code));
                                    }
                                }
                                else
                                {
                                    website =JsonDocument.Parse(activityWebsiteResponse.Content).RootElement.ToObject<ActivityWebsite>();
                                }
                            }
                            //醍摩豆智慧学区
                            if (activity.scope.Equals("public", StringComparison.OrdinalIgnoreCase))
                            {
                                if (website.allowPublic==0)
                                {
                                    return Ok(new { code = 2, msg = "暂无创建公开活动权限！" });
                                }
                            }
                            Contest contest = null;
                            ValidResult validResult = activity.Valid();
                            if (validResult.isVaild)
                            {
                                activity.creatorId=tmdid;
                                activity.createTime= DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                activity.year=DateTimeOffset.Now.Year;
                                foreach (var module in activity.modules)
                                {
                                    switch (true)
                                    {
                                        //赛课
                                        case bool when module.Equals("Contest"):
                                            {
                                                if (!request.TryGetProperty("Contest", out JsonElement _contest))
                                                {
                                                    return Ok(new { code = 3, msg = "赛课信息参数错误" });
                                                }
                                                contest = _contest.ToObject<Contest>();
                                                if (contest!=null)
                                                {
                                                    contest.id=activity.id;
                                                    contest.code="Contest";
                                                    contest.pk="Contest";
                                                    ValidResult validResultContest = contest.Valid();
                                                    if (validResultContest.isVaild)
                                                    {

                                                        if (contest.modules.Contains("review"))
                                                        {
                                                            if (!request.TryGetProperty("reviewConfig", out JsonElement _reviewConfig))
                                                            {
                                                                return Ok(new { code = 4, msg = "评审未配置" });
                                                            }
                                                            if (contest.review== null)
                                                            {
                                                                return Ok(new { code = 4, msg = "评审未配置" });
                                                            }
                                                            ReviewRuleTree ruleTree = _reviewConfig.ToObject<ReviewRuleTree>();
                                                            var reviewRuleResult = await ActivityService.UpsertReviewRule(ruleTree, activity, contest, _azureCosmos);
                                                            if (reviewRuleResult.invalidCode!=200)
                                                            {
                                                                return Ok(new { code = reviewRuleResult.invalidCode, msg = reviewRuleResult.msg });
                                                            }
                                                            contest.review.ruleId =reviewRuleResult.reviewRule.id;
                                                            contest.review.ruleName = reviewRuleResult.reviewRule.name;
                                                        }
                                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(contest, new PartitionKey(contest.code));
                                                        break;
                                                    }
                                                    else
                                                    {
                                                        return Ok(validResult);
                                                    }
                                                }
                                                else
                                                {
                                                    return Ok(validResult);
                                                }
                                            }
                                        //培训
                                        case bool when module.Equals("Training"):
                                            {
                                                break;
                                            }
                                        //教研
                                        case bool when module.Equals("Research"):
                                            {
                                                break;
                                            }
                                    }
                                }
                                //保存活动基础信息
                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(activity, new PartitionKey(activity.code));
                                return Ok(new { activity, contest, code = 200 });
                            }
                            else
                            {
                                return Ok(validResult);
                            }
                        }
                    //删除活动
                    case bool when $"{grant_type}".Equals("delete", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("owner", out JsonElement _owner)) return BadRequest();
                            if (!request.TryGetProperty("scope", out JsonElement _scope)) return BadRequest();
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
                            if (response.Status==200)
                            {
                                Activity activity = JsonDocument.Parse(response.Content).RootElement.ToObject<Activity>();
                                if (_scope.GetString().Equals("school")  && _owner.GetString().Equals(school))
                                {
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).DeleteItemStreamAsync(activity.id, new PartitionKey("Activity"));
                                    await ActivityService.DeleteActivityRelated(_azureCosmos, activity);
                                    return Ok(new { code = 201, activity }); //删除成功
                                }
                                else
                                {
                                    if ((_scope.GetString().Equals("area")  ||  _scope.GetString().Equals("public"))  && !_owner.GetString().Equals(school))
                                    {
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).DeleteItemStreamAsync(activity.id, new PartitionKey("Activity"));
                                        await ActivityService.DeleteActivityRelated(_azureCosmos, activity);
                                        return Ok(new { code = 201, activity });//删除成功
                                    }
                                }
                                return Ok(new { code = 200, activity });//未删除掉
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "活动不存在" });
                            }
                        }
                    //区级活动列表
                    case bool when $"{grant_type}".Equals("list-area", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("areaId", out JsonElement _areaId)) return BadRequest();
                            var activities = await ActivityService.AreaActivityList(_azureCosmos, _azureStorage, request, _areaId.GetString());
                            return Ok(new { activities = activities });
                        }
                    //校级活动列表
                    case bool when $"{grant_type}".Equals("list-school", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!string.IsNullOrWhiteSpace(school))
                            {
                                var activities = await ActivityService.SchoolActivityList(_azureCosmos, _azureStorage, request, school);
                                return Ok(new { code = 200, activities = activities.OrderByDescending(z => z.stime) });
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "没有学校信息" });
                            }
                        }
                    //教师活动列表
                    case bool when $"{grant_type}".Equals("list-teacher", StringComparison.OrdinalIgnoreCase):
                        {
                            List<TeacherActivityDto> activities = await ActivityService.TeacherActivityList(_azureCosmos, _azureStorage, request, tmdid);
                            return Ok(new { activities = activities.OrderByDescending(z => z.stime) });
                        }
                    case bool when $"{grant_type}".Equals("list-year", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("type", out JsonElement _type)) return BadRequest();
                            if (!request.TryGetProperty("ownerId", out JsonElement ownerId)) return BadRequest();
                            if ($"{_type}".Equals("teacher"))
                            {
                                var data = await ActivityService.TeacherActivityList(_azureCosmos, _azureStorage, request, ownerId.GetString(),1);
                                var countYear = data.GroupBy(z => z.year).Select(z => new { year = z.Key, count = z.ToList().Count() });
                                return Ok(new { code = 200, countYear });
                            }
                            else if ($"{_type}".Equals("school"))
                            {
                                var data = await ActivityService.SchoolActivityList(_azureCosmos, _azureStorage, request, ownerId.GetString(),1);
                                var countYear = data.GroupBy(z => z.year).Select(z => new { year = z.Key, count = z.ToList().Count() });
                                return Ok(new { code = 200, countYear });
                            }
                            else if ($"{_type}".Equals("area"))
                            {
                                var data = await ActivityService.AreaActivityList(_azureCosmos, _azureStorage, request, ownerId.GetString(), 1);
                                var countYear = data.GroupBy(z => z.year).Select(z => new { year = z.Key, count = z.ToList().Count() });
                                return Ok(new { code = 200, countYear });
                            }
                            else
                            {
                                return BadRequest("类型错误！");
                            }
                        }
                    case bool when $"{grant_type}".Equals("read-activity", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
                            if (response.Status==200)
                            {
                                ActivityDto activity = JsonDocument.Parse(response.Content).RootElement.ToObject<ActivityDto>();
                                Contest contest = null;
                                ReviewRuleTree reviewRule = null;
                                Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                if (responseContest.Status==200)
                                {
                                    contest= JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                    if (contest.modules.Contains("review"))
                                    {
                                        Azure.Response reviewRuleResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("ReviewRule-disposable"));
                                        if (reviewRuleResponse.Status==200)
                                        {
                                            ReviewRule reviewRuleDB = JsonDocument.Parse(reviewRuleResponse.Content).RootElement.ToObject<ReviewRule>();
                                            var tree = ActivityService.ListToTree(reviewRuleDB.configs);
                                            reviewRule=new ReviewRuleTree
                                            {
                                                id=reviewRuleDB.id,
                                                name= reviewRuleDB.name,
                                                owner= reviewRuleDB.owner,
                                                sourceName= reviewRuleDB.sourceName,
                                                trees=tree,
                                                desc=reviewRuleDB.desc,
                                                scoreDetail=reviewRuleDB.scoreDetail,
                                                scoreRule=reviewRuleDB.scoreRule,
                                                distribute=reviewRuleDB.distribute,
                                                taskCount=reviewRuleDB.taskCount,
                                            };
                                        }
                                    }
                                }
                                Training training = null;
                                TEAMModelOS.SDK.Models.Research research = null;
                                var (blob_uri, blob_sas) = _azureStorage.GetBlobContainerSAS(activity.owner, BlobContainerSasPermissions.Read | BlobContainerSasPermissions.List);
                                activity.sas=blob_sas;
                                activity.url=blob_uri;
                                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                activity.publish=now>activity.etime ? 2 : activity.publish;
                                return Ok(new { code = 200, activity, contest, reviewRule, training, research });
                            }
                            else
                            {
                                return Ok(new { code = 2, msg = "活动不存在" });
                            }
                        }
                    //读取优课评选模块及评审规则
                    case bool when $"{grant_type}".Equals("read-Contest", StringComparison.OrdinalIgnoreCase):
                        {
                            Contest contest = null;
                            ReviewRuleTree reviewRule = null;
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                            if (response.Status==200)
                            {
                                contest= JsonDocument.Parse(response.Content).RootElement.ToObject<Contest>();
                                if (contest.modules.Contains("review"))
                                {
                                    Azure.Response reviewRuleResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("ReviewRule-disposable"));
                                    if (reviewRuleResponse.Status==200)
                                    {
                                        ReviewRule reviewRuleDB = JsonDocument.Parse(reviewRuleResponse.Content).RootElement.ToObject<ReviewRule>();
                                        var tree = ActivityService.ListToTree(reviewRuleDB.configs);
                                        reviewRule= new ReviewRuleTree
                                        {
                                            id=reviewRuleDB.id,
                                            name= reviewRuleDB.name,
                                            owner= reviewRuleDB.owner,
                                            sourceName= reviewRuleDB.sourceName,
                                            trees=tree,
                                            desc=reviewRuleDB.desc,
                                            distribute=reviewRuleDB.distribute,
                                            taskCount=reviewRuleDB.taskCount,
                                            scoreDetail=reviewRuleDB.scoreDetail,
                                            scoreRule=reviewRuleDB.scoreRule,
                                        };
                                    }
                                }
                            }
                            return Ok(new { code = 200, contest, reviewRule });
                        }
                    //获取评审的模板列表
                    case bool when $"{grant_type}".Equals("rule-list", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("owner", out JsonElement _owner)) return BadRequest();
                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).GetList<ReviewRule>($"select value c from c where c.owner='{_owner}'", "ReviewRule-template");
                            List<ReviewRuleTree> reviewRules = new List<ReviewRuleTree>();
                            foreach (var item in result.list)
                            {
                                var tree = ActivityService.ListToTree(item.configs);
                                ReviewRuleTree reviewRule = new ReviewRuleTree
                                {
                                    id=item.id,
                                    desc=item.desc,
                                    name= item.name,
                                    owner= item.owner,
                                    sourceName= item.sourceName,
                                    trees=tree,
                                    upsertAsTemplate=1,
                                    taskCount=item.taskCount,
                                    scoreRule=item.scoreRule,
                                    distribute=item.distribute,
                                    scoreDetail=item.scoreDetail
                                };
                                reviewRules.Add(reviewRule);
                            }
                            return Ok(new { reviewRules });
                        }
                    //编辑当前活动评审规则
                    case bool when $"{grant_type}".Equals("rule-update", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("reviewConfig", out JsonElement _reviewConfig))
                            {
                                return Ok(new { code = 4, msg = "评审未配置" });
                            }
                            ReviewRuleTree ruleTree = _reviewConfig.ToObject<ReviewRuleTree>();
                            if (!string.IsNullOrWhiteSpace(ruleTree.id))
                            {
                                Activity activity = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemAsync<Activity>(ruleTree.id, new PartitionKey("Activity"));
                                Contest contest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemAsync<Contest>(ruleTree.id, new PartitionKey("Contest"));
                                var reviewRuleResult = await ActivityService.UpsertReviewRule(ruleTree, activity, contest, _azureCosmos);

                                if (reviewRuleResult.invalidCode!=200)
                                {
                                    return Ok(new { code = reviewRuleResult.invalidCode, msg = reviewRuleResult.msg });
                                }
                                var tree = ActivityService.ListToTree(reviewRuleResult.reviewRule.configs);
                                var reviewRule = new ReviewRuleTree
                                {
                                    id=reviewRuleResult.reviewRule.id,
                                    name= reviewRuleResult.reviewRule.name,
                                    owner= reviewRuleResult.reviewRule.owner,
                                    sourceName= reviewRuleResult.reviewRule.sourceName,
                                    trees=tree,
                                    desc=reviewRuleResult.reviewRule.desc,
                                    distribute=reviewRuleResult.reviewRule.distribute,
                                    scoreDetail=reviewRuleResult.reviewRule.scoreDetail,
                                    scoreRule=reviewRuleResult.reviewRule.scoreRule,
                                    taskCount=reviewRuleResult.reviewRule.taskCount,
                                };
                                return Ok(new { reviewRule });
                            }
                            else
                            {
                                return Ok(new { code = 5, msg = "规则不存在" });
                            }
                        }
                    //删除评审规则模板
                    case bool when $"{grant_type}".Equals("rule-delete", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("ruleId", out JsonElement _ruleId))
                            {
                                return BadRequest();
                            }
                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).DeleteItemStreamAsync(_ruleId.GetString(), new PartitionKey("ReviewRule-template"));
                            return Ok(new { code = 200 });
                        }
                    case bool when $"{grant_type}".Equals("invite-remove-school", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("invitedSchools", out JsonElement _invitedSchools)) return BadRequest();
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
                            if (response.Status==200)
                            {
                                List<ActivityInvitedSchool> invitedSchools = _invitedSchools.ToObject<List<ActivityInvitedSchool>>();
                                Activity activity = JsonDocument.Parse(response.Content).RootElement.ToObject<Activity>();
                                foreach (var invitedSchool in invitedSchools)
                                {
                                    if (!activity.invitedSchools.Exists(z => z.id.Equals(invitedSchool.id)))
                                    {
                                        activity.invitedSchools.Add(invitedSchool);
                                    }
                                }
                                return Ok(new { code = 200, activity });
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "活动不存在" });
                            }

                        }
                    //学校确认参加本次活动
                    case bool when $"{grant_type}".Equals("school-confirm", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("confirm", out JsonElement _confirm)) return BadRequest();
                            if (!string.IsNullOrWhiteSpace(school))
                            {
                                Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
                                if (response.Status==200)
                                {
                                    Activity activity = JsonDocument.Parse(response.Content).RootElement.ToObject<Activity>();
                                    if (_confirm.GetInt32()==1 ||_confirm.GetInt32()==0)
                                    {
                                        var invitedSchool = activity.invitedSchools.Find(z => z.id.Equals(school));
                                        if (invitedSchool!=null ||
                                            //如果是区级，且没选择学校，也需要确认
                                            (activity.scope.Equals("area")  && !activity.invitedSchools.IsNotEmpty()))
                                        {
                                            var confirmedSchool = activity.confirmedSchools.Find(z => z.id.Equals(school));
                                            if (confirmedSchool!=null)
                                            {
                                                confirmedSchool.status=_confirm.GetInt32();
                                            }
                                            else
                                            {
                                                School schoolbase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                                                if (activity.scope.Equals("area"))
                                                {
                                                    if (string.IsNullOrWhiteSpace(schoolbase.areaId) || !schoolbase.areaId.Equals(activity.owner))
                                                    {
                                                        return Ok(new { code = 5, msg = "学校的区级与活动所属区级不一致!" });
                                                    }
                                                }
                                                activity.confirmedSchools= new List<ActivityConfirmedSchool>() { new ActivityConfirmedSchool { id=school, status=_confirm.GetInt32(), name=schoolbase.name, picture= schoolbase.picture } };
                                            }
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(activity, new PartitionKey("Activity"));
                                            return Ok(new { code = 200, activity });
                                        }
                                        else
                                        {
                                            return Ok(new { code = 1, msg = "该学校未被邀请!" });
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "活动发布状态错误!" });
                                    }
                                }
                                else
                                {
                                    return Ok(new { code = 4, msg = "活动不存在!" });
                                }
                            }
                            else
                            {
                                return Ok(new { code = 3, msg = "没有学校信息!" });
                            }
                        }
                    //发布或取消发布活动
                    case bool when $"{grant_type}".Equals("update-publish", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("publish", out JsonElement _publish)) return BadRequest();
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
                            if (response.Status==200)
                            {
                                Activity activity = JsonDocument.Parse(response.Content).RootElement.ToObject<Activity>();
                                if (_publish.GetInt32()==1 ||_publish.GetInt32()==0)
                                {
                                    activity.publish=_publish.GetInt32();
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(activity, new PartitionKey("Activity"));
                                    return Ok(new { code = 200, activity });
                                }
                                else
                                {
                                    return Ok(new { code = 2, msg = "活动发布状态错误!" });
                                }
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "活动不存在" });
                            }
                        }
                    //邀请教师参加本次活动或移除教师参加活动
                    case bool when $"{grant_type}".Equals("invite-remove-teachers", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            request.TryGetProperty("invite", out JsonElement _invite);
                            request.TryGetProperty("remove", out JsonElement _remove);
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
                            if (response.Status==200)
                            {
                                Activity activity = JsonDocument.Parse(response.Content).RootElement.ToObject<Activity>();
                                if (activity.joinMode.Equals("invite"))
                                {

                                    var confirmedSchool = activity.confirmedSchools.Find(z => z.id.Equals(school)  && z.status==1);
                                    if (confirmedSchool!= null  ||  activity.scope.Equals("school", StringComparison.OrdinalIgnoreCase))
                                    {
                                        List<InviteTeachers> inviteTeachersInvalid = new List<InviteTeachers>();
                                        List<InviteTeachers> removeTeachersInvalid = new List<InviteTeachers>();
                                        ActivityTeacher activityTeacher = null;
                                        Azure.Response activityTeacherResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(school, new PartitionKey($"ActivityTeacher-{activity.id}"));
                                        if (activityTeacherResponse.Status==200)
                                        {
                                            activityTeacher = JsonDocument.Parse(activityTeacherResponse.Content).RootElement.ToObject<ActivityTeacher>();
                                        }
                                        if (activityTeacher==null)
                                        {
                                            activityTeacher= new ActivityTeacher() { activityId=_activityId.GetString(), schoolName= activity.scope.Equals("school")  && confirmedSchool== null ? activity.ownerName : confirmedSchool.name, id=school, code=$"ActivityTeacher-{_activityId}", pk="ActivityTeacher" };
                                        }
                                        if (_invite.ValueKind.Equals(JsonValueKind.Array))
                                        {
                                            List<InviteTeachers> inviteTeachers = _invite.ToObject<List<InviteTeachers>>();
                                            foreach (var invite in inviteTeachers)
                                            {
                                                if (string.IsNullOrWhiteSpace(invite.school)  ||  !invite.school.Equals(school))
                                                {
                                                    inviteTeachersInvalid.Add(invite);
                                                    continue;
                                                }
                                                var inviteTeacher = activityTeacher.inviteTeachers.Find(z => z.id.Equals(invite.id));
                                                if (inviteTeacher==null)
                                                {
                                                    activityTeacher.inviteTeachers.Add(invite);
                                                }
                                                else
                                                {
                                                    inviteTeacher=invite;
                                                }
                                            }
                                        }
                                        if (_remove.ValueKind.Equals(JsonValueKind.Array))
                                        {
                                            List<InviteTeachers> removeTeachers = _remove.ToObject<List<InviteTeachers>>();
                                            foreach (var remove in removeTeachers)
                                            {
                                                if (string.IsNullOrWhiteSpace(remove.school)  || !remove.school.Equals(school))
                                                {
                                                    removeTeachersInvalid.Add(remove);
                                                    continue;
                                                }
                                                activityTeacher.inviteTeachers.RemoveAll(z => remove.id.Equals(z.id));
                                            }
                                        }
                                        var teachers = activityTeacher.inviteTeachers.FindAll(z => z.school.Equals(school));
                                        activityTeacher.activityId=$"{_activityId}";
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityTeacher, new PartitionKey($"ActivityTeacher-{_activityId}"));
                                        return Ok(new { inviteTeachers = teachers, inviteTeachersInvalid, removeTeachersInvalid });
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "学校未确认，暂不能邀请教师" });
                                    }
                                }
                                else
                                {
                                    return Ok(new { code = 3, msg = "活动不是邀请制。" });
                                }
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "活动不存在" });
                            }
                        }
                    //获取单个教师的报名数据
                    case bool when $"{grant_type}".Equals("get-teacher-enroll", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("teacherId", out JsonElement _teacherId)) return BadRequest();
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            ActivityEnroll enroll = null;
                            Azure.Response responseActivityEnroll = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync($"{_teacherId}", new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                            if (responseActivityEnroll.Status==200)
                            {
                                enroll= JsonDocument.Parse(responseActivityEnroll.Content).RootElement.ToObject<ActivityEnroll>();
                                return Ok(new { code = 200, enroll });
                            }
                            return Ok(new { code = 1, msg = "暂无报名数据！", });
                        }
                    //获取邀请的教师列表
                    case bool when $"{grant_type}".Equals("invited-teachers", StringComparison.OrdinalIgnoreCase)
                                || $"{grant_type}".Equals("invited-and-enroll-teachers", StringComparison.OrdinalIgnoreCase):
                        {
                            string owner = string.Empty;
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            request.TryGetProperty("activityOwner", out JsonElement _activityOwner);
                            if (string.IsNullOrWhiteSpace($"{_activityOwner}"))
                            {
                                if (!string.IsNullOrWhiteSpace(school))
                                {
                                    owner=school;
                                }
                            }
                            else
                            {
                                owner=$"{_activityOwner}";
                            }
                            Activity activity = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemAsync<Activity>(_activityId.GetString(), new PartitionKey("Activity"));
                            int isAll = 0;
                            if (!string.IsNullOrWhiteSpace(owner))
                            {
                                if (activity.owner.Equals(owner))
                                {
                                    isAll = 1;
                                }
                            }
                            List<InviteTeachers> inviteTeachers = new List<InviteTeachers>();

                            string activityTeacherSQL = $"select value c from c where c.pk='ActivityTeacher'";

                            if (isAll!=1 && !string.IsNullOrWhiteSpace(school))
                            {
                                activityTeacherSQL=$"{activityTeacherSQL} and c.id='{school}'";
                            }
                            var activityTeacherResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityTeacher>(activityTeacherSQL, $"ActivityTeacher-{_activityId}");
                            foreach (var activityTeacher in activityTeacherResult.list)
                            {
                                inviteTeachers.AddRange(activityTeacher.inviteTeachers);
                            }
                            if ($"{grant_type}".Equals("invited-and-enroll-teachers", StringComparison.OrdinalIgnoreCase))
                            {
                                string enrollSQL = $"select value c from c where c.activityId='{_activityId.GetString()}' ";
                                //不是自己的，且学校不为空，则查询指定学校的，否则获取所有报名的数据
                                if (isAll!=1 && !string.IsNullOrWhiteSpace(school))
                                {
                                    enrollSQL=$"{enrollSQL} and c.schoolId='{school}'";
                                }
                                var enrollResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(enrollSQL, $"ActivityEnroll-{_activityId}");
                                List<InviteEnrollTeacherDto> inviteEnrollTeachers = new List<InviteEnrollTeacherDto>();
                                Contest contest = null;
                                Azure.Response contestResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                if (contestResponse.Status==200)
                                {
                                    contest = JsonDocument.Parse(contestResponse.Content).RootElement.ToObject<Contest>();
                                }
                                long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                                int uploadStatus = -1;
                                int contestStatus = -1;
                                if (contest?.sign!=null)
                                {
                                    if (contest?.sign.stime>now)
                                    {
                                        contestStatus=-2;
                                    }
                                    else
                                    {
                                        contestStatus = 0;
                                    }
                                }
                                if (contest?.upload!=null)
                                {
                                    if (contest?.upload.stime>now)
                                    {
                                        uploadStatus=-2;
                                    }
                                    else
                                    {
                                        uploadStatus=0;
                                    }
                                }
                                foreach (var inviteTeacher in inviteTeachers)
                                {
                                    inviteEnrollTeachers.Add(new InviteEnrollTeacherDto
                                    {
                                        id= inviteTeacher.id,
                                        name= inviteTeacher.name,
                                        picture= inviteTeacher.picture,
                                        school= inviteTeacher.school,
                                        schoolName=inviteTeacher.schoolName,
                                        inviteStatus=inviteTeacher.status,
                                        signContestStatus=contestStatus,
                                        uploadContestStatus=uploadStatus
                                    });
                                }
                                foreach (var activityEnroll in enrollResult.list)
                                {
                                    var inviteEnrollTeacher = inviteEnrollTeachers.Find(z => z.id.Equals(activityEnroll.id)   &&  !string.IsNullOrWhiteSpace(z.school)  && !string.IsNullOrEmpty(activityEnroll.schoolId)  && z.school.Equals(activityEnroll.schoolId));
                                    if (inviteEnrollTeacher==null)
                                    {
                                        inviteEnrollTeacher= new InviteEnrollTeacherDto
                                        {
                                            id= activityEnroll.id,
                                            name= activityEnroll.tmdName,
                                            picture= activityEnroll.tmdPicture,
                                            school= activityEnroll.schoolId,
                                            schoolName=activityEnroll.schoolName,
                                            signContestStatus=contestStatus,
                                            uploadContestStatus=uploadStatus
                                        };
                                        inviteEnrollTeachers.Add(inviteEnrollTeacher);
                                    }
                                    if (activityEnroll.contest!= null)
                                    {
                                        inviteEnrollTeacher.signContestStatus = 1;
                                        inviteEnrollTeacher.signContestTime = activityEnroll.contest.enrollTime;
                                        inviteEnrollTeacher.signContestType = activityEnroll.contest.type;
                                        inviteEnrollTeacher.teamCipherContest=activityEnroll.contest.cipher;
                                        inviteEnrollTeacher.teamLeaderContest=activityEnroll.contest.leader;
                                        inviteEnrollTeacher.teamNameContest=activityEnroll.contest.teamName;
                                    }
                                    if (activityEnroll.upload!=null)
                                    {
                                        inviteEnrollTeacher.uploadContestId=activityEnroll.upload.uploadId;
                                        //inviteEnrollTeacher.uploadContestType=activityEnroll.upload.type;
                                        inviteEnrollTeacher.uploadContestTypes= activityEnroll.upload.uploadType;
                                        inviteEnrollTeacher.uploadContestStatus=1;
                                        inviteEnrollTeacher.uploadContestTime= activityEnroll.upload.uploadTime;
                                        inviteEnrollTeacher.uploadContestScore=activityEnroll.upload.score;
                                    }
                                }
                                //进入评审环节
                                if (contest.review!= null  && now > contest.review.stime)
                                {
                                    HashSet<string> uploadContestIds = inviteEnrollTeachers.Where(x => !string.IsNullOrWhiteSpace(x.uploadContestId)).Select(z => z.uploadContestId).ToHashSet();
                                    if (uploadContestIds!= null && uploadContestIds.Count>0)
                                    {
                                        // List<ActivityExpertTask> expertTasks = new List<ActivityExpertTask>();
                                        string taskSQL = $"select distinct value c from c  join s in c.contestTasks  where c.pk='ActivityExpertTask' and s.uploadId in ({string.Join(",", uploadContestIds.Select(z => $"'{z}'"))})";
                                        List<ExpertContestTaskDto> worksDB = new List<ExpertContestTaskDto>();
                                       
                                        var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(taskSQL, $"ActivityExpertTask-{_activityId}");
                                        if (result.list.IsNotEmpty())
                                        {
                                            List<ActivityExpertTask> change = new List<ActivityExpertTask>();
                                            var experts = await ActivityService.ListExperts(_azureCosmos, _coreAPIHttpService, _dingDing, _option, $"{_activityId}");
                                            foreach (var item in result.list)
                                            {
                                                var expert= experts.Find(x => !string.IsNullOrWhiteSpace(x.id) &&  x.id.Equals(item.id));
                                                if (expert!=null) 
                                                {
                                                    foreach (var task in item.contestTasks)
                                                    {
                                                        var teachers = inviteEnrollTeachers.FindAll(z => !string.IsNullOrWhiteSpace(z.uploadContestId) && z.uploadContestId.Equals(task.uploadId));
                                                        if (teachers!=null)
                                                        {
                                                            teachers.ForEach(z => {
                                                                z.reviewContestAssignCount+=1;
                                                                z.reviewContestExperts.Add(new ExpertUploadScore
                                                                {
                                                                    score=task.score,
                                                                    detailScore=task.detailScore,
                                                                    id= item.id,
                                                                    name=item.name,
                                                                    nickname=item.tmdname,
                                                                    picture=item.picture
                                                                });
                                                            });
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    change.Add(item);
                                                }
                                            }
                                            if (change.IsNotEmpty()) {
                                              await  _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).DeleteItemsAsync<ActivityExpertTask>(change.Select(x=>x.id).ToList(),$"ActivityExpertTask-{_activityId}");
                                            }
                                        }
                                    }
                                }
                                return Ok(new { code = 200, inviteEnrollTeachers });
                            }
                            else
                            {
                                return Ok(new { code = 200, inviteTeachers });
                            }
                        }
                    //导入评审专家
                    case bool when $"{grant_type}".Equals("add-remove-experts", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            List<Expert> upsert_experts = new List<Expert>();
                            List<Expert> remove_experts = new List<Expert>();
                            if (request.TryGetProperty("upsert_experts", out JsonElement _upsert_experts) && _upsert_experts.ValueKind.Equals(JsonValueKind.Array))
                            {
                                upsert_experts = _upsert_experts.ToObject<List<Expert>>();
                            }
                            if (request.TryGetProperty("remove_experts", out JsonElement _remove_experts) && _remove_experts.ValueKind.Equals(JsonValueKind.Array))
                            {
                                remove_experts = _remove_experts.ToObject<List<Expert>>();
                            }
                            ActivityExpert activityExpert = null;
                            if (upsert_experts.IsNotEmpty())
                            {
                                var tmdids = upsert_experts.Where(x => !string.IsNullOrWhiteSpace(x.tmdid)).Select(z => z.tmdid);
                                var phones = upsert_experts.Where(x => !string.IsNullOrWhiteSpace(x.mobile)).Select(z => z.mobile);
                                var emails = upsert_experts.Where(x => !string.IsNullOrWhiteSpace(x.email)).Select(z => z.email);
                                List<string> keys = new List<string>();
                                if (tmdids.Any())
                                {
                                    keys.AddRange(tmdids);
                                }
                                if (phones.Any())
                                {
                                    keys.AddRange(phones);
                                }
                                if (emails.Any())
                                {
                                    keys.AddRange(emails);
                                }

                                upsert_experts.ForEach(x => { x.status = 0; x.iname = x.name; x.name = null; });
                                List<CoreUser> coreUsers = new List<CoreUser>();
                                if (keys.Any())
                                {
                                    try
                                    {
                                        var content = new StringContent(keys.ToJsonString(), Encoding.UTF8, "application/json");
                                        string json = await _coreAPIHttpService.GetUserInfos(content);
                                        if (!string.IsNullOrWhiteSpace(json))
                                        {
                                            coreUsers = json.ToObject<List<CoreUser>>();
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        await _dingDing.SendBotMsg($"{_option.Location},导入名单时，查验key信息错误{ex.Message}\n{ex.StackTrace}\n\n{keys.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
                                    }
                                }
                                if (coreUsers.IsNotEmpty())
                                {
                                    foreach (var t in upsert_experts)
                                    {
                                        if (!string.IsNullOrWhiteSpace(t.tmdid))
                                        {
                                            CoreUser coreUser = coreUsers.Find(x => x.id.Equals(t.tmdid));
                                            if (coreUser != null)
                                            {
                                                t.id = coreUser.id;
                                                t.name = coreUser.name;
                                                t.picture = coreUser.picture;
                                                t.tmdid = coreUser.id;
                                                if (!string.IsNullOrWhiteSpace(coreUser.mobile))
                                                {
                                                    t.mobile = coreUser.mobile;
                                                }
                                                if (!string.IsNullOrWhiteSpace(coreUser.mail))
                                                {
                                                    t.email = coreUser.mail;
                                                }
                                            }
                                        }
                                        if (string.IsNullOrWhiteSpace(t.id))
                                        {
                                            if (!string.IsNullOrWhiteSpace(t.mobile))
                                            {
                                                CoreUser coreUser = coreUsers.Find(x => !string.IsNullOrWhiteSpace(x.mobile) && x.mobile.Equals(t.mobile));
                                                if (coreUser != null)
                                                {
                                                    t.id = coreUser.id;
                                                    t.name = coreUser.name;
                                                    t.picture = coreUser.picture;
                                                    t.tmdid = coreUser.id;
                                                    if (!string.IsNullOrWhiteSpace(coreUser.mobile))
                                                    {
                                                        t.mobile = coreUser.mobile;
                                                    }
                                                    if (!string.IsNullOrWhiteSpace(coreUser.mail))
                                                    {
                                                        t.email = coreUser.mail;
                                                    }
                                                }
                                            }
                                        }
                                        if (string.IsNullOrWhiteSpace(t.id))
                                        {
                                            if (!string.IsNullOrWhiteSpace(t.email))
                                            {
                                                CoreUser coreUser = coreUsers.Find(x => !string.IsNullOrWhiteSpace(x.mail) && x.mail.Equals(t.email));
                                                if (coreUser != null)
                                                {
                                                    t.id = coreUser.id;
                                                    t.name = coreUser.name;
                                                    t.picture = coreUser.picture;
                                                    t.tmdid = coreUser.id;
                                                    if (!string.IsNullOrWhiteSpace(coreUser.mobile))
                                                    {
                                                        t.mobile = coreUser.mobile;
                                                    }
                                                    if (!string.IsNullOrWhiteSpace(coreUser.mail))
                                                    {
                                                        t.email = coreUser.mail;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync($"{_activityId}", new PartitionKey("ActivityExpert"));
                                    if (response.Status == 200)
                                    {
                                        activityExpert = JsonDocument.Parse(response.Content).RootElement.Deserialize<ActivityExpert>();
                                        upsert_experts.ForEach(x =>
                                        {
                                            Expert tch = null;
                                            if (string.IsNullOrWhiteSpace(x.id))
                                            {
                                                tch = activityExpert.experts.Find(t => !string.IsNullOrWhiteSpace(t.iname) && t.iname.Equals(x.iname));
                                            }
                                            else
                                            {
                                                tch = activityExpert.experts.Find(t => !string.IsNullOrWhiteSpace(x.id) && !string.IsNullOrWhiteSpace(t.id) && t.id.Equals(x.id));
                                            }
                                            if (tch != null)
                                            {
                                                tch.status = x.status;
                                                tch.name = x.name;
                                                tch.iname = x.iname;
                                                tch.picture = x.picture;
                                                tch.mobile = x.mobile;
                                                tch.tmdid = x.tmdid;
                                                tch.email = x.email;
                                                tch.id = x.id;
                                                tch.school = x.school;
                                                //直接替换更新
                                                tch.modules=x.modules;
                                                tch.subjects=x.subjects;
                                                //    x.modules.ForEach(y => {
                                                //        if (!tch.modules.Contains(y))
                                                //        {
                                                //            tch.modules.Add(y);
                                                //        }
                                                //    });
                                                //    x.subjects.ForEach(r => {
                                                //        if (!string.IsNullOrWhiteSpace(r.subject)  && !string.IsNullOrWhiteSpace(r.period))
                                                //        {
                                                //            var sub = tch.subjects.Find(x => !string.IsNullOrWhiteSpace(x.subject)  && !string.IsNullOrWhiteSpace(x.period)  && x.subject.Equals(r.subject)  && x.period.Equals(r.period));
                                                //            if (sub == null)
                                                //            {
                                                //                tch.subjects.Add(r);
                                                //            }
                                                //        }
                                                //        if (!string.IsNullOrWhiteSpace(r.subject)  && string.IsNullOrWhiteSpace(r.period))
                                                //        {
                                                //            var sub = tch.subjects.Find(a => !string.IsNullOrWhiteSpace(a.subject)  && string.IsNullOrWhiteSpace(a.period)  && a.subject.Equals(r.subject));
                                                //            if (sub == null)
                                                //            {
                                                //                tch.subjects.Add(r);
                                                //            }
                                                //        }
                                                //    });
                                            }
                                            else
                                            {
                                                activityExpert.experts.Add(new Expert
                                                {
                                                    status = x.status,
                                                    name = x.name,
                                                    iname = x.iname,
                                                    picture = x.picture,
                                                    mobile = x.mobile,
                                                    tmdid = x.tmdid,
                                                    email = x.email,
                                                    id = x.id,
                                                    title = x.title,
                                                    subjects = x.subjects,
                                                    modules = x.modules,
                                                    school=x.school,
                                                });
                                            }
                                        });
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityExpert, new PartitionKey("ActivityExpert"));
                                    }
                                    else
                                    {
                                        activityExpert = new ActivityExpert { id = $"{_activityId}", code = "ActivityExpert", pk = "ActivityExpert", experts = upsert_experts };
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityExpert, new PartitionKey("ActivityExpert"));
                                    }
                                }
                                else
                                {
                                    activityExpert = new ActivityExpert { id = $"{_activityId}", code = "ActivityExpert", pk = "ActivityExpert", experts = upsert_experts };
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityExpert, new PartitionKey("ActivityExpert"));
                                }
                                
                            }
                            if (remove_experts.IsNotEmpty())
                            {
                                if (activityExpert == null)
                                {
                                    Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync($"{_activityId}", new PartitionKey("ActivityExpert"));
                                    if (response.Status == 200)
                                    {
                                        activityExpert = JsonDocument.Parse(response.Content).RootElement.Deserialize<ActivityExpert>();
                                    }
                                }
                                if (activityExpert!=null)
                                {
                                    remove_experts.ForEach(z => {
                                        if (!string.IsNullOrWhiteSpace(z.id))
                                        {
                                            activityExpert.experts.RemoveAll(x => !string.IsNullOrWhiteSpace(x.id)  && x.id.Equals(z.id));
                                        }
                                        else
                                        {
                                            if (!string.IsNullOrWhiteSpace(z.mobile))
                                            {
                                                activityExpert.experts.RemoveAll(x => !string.IsNullOrWhiteSpace(x.mobile)  && x.mobile.Equals(z.mobile));
                                            }
                                            if (!string.IsNullOrWhiteSpace(z.email))
                                            {
                                                activityExpert.experts.RemoveAll(x => !string.IsNullOrWhiteSpace(x.email)  && x.email.Equals(z.email));
                                            }
                                            if (!string.IsNullOrWhiteSpace(z.tmdid))
                                            {
                                                activityExpert.experts.RemoveAll(x => !string.IsNullOrWhiteSpace(x.tmdid)  && x.tmdid.Equals(z.tmdid));
                                            }
                                        }
                                    });
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityExpert, new PartitionKey("ActivityExpert"));
                                }
                            }
                            return Ok(new { activityExpert, code = 200 });
                        }
                    //评审专家列表
                    case bool when $"{grant_type}".Equals("list-experts", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            var expertTasks = await  ActivityService.ListExperts(_azureCosmos, _coreAPIHttpService, _dingDing, _option, $"{_activityId}");
                            return Ok(new { expertTasks, code = 200 });
                        }
                    case bool when $"{grant_type}".Equals("update-reviewStatus", StringComparison.OrdinalIgnoreCase): 
                        {

                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("reviewStatus", out JsonElement _reviewStatus)) return BadRequest();
                            Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                            if (responseContest.Status == 200)
                            {
                                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                if (contest.modules.Contains("review") && contest.review != null)
                                {
                                    //只有开启评审的时候才去检查评审时间， 取消评审不用检查。
                                    if ($"{_reviewStatus}".Equals("1")  && (now < contest.review.stime || now > contest.review.etime))
                                    {
                                        return Ok(new { code = 1, msg = "不在评审时间范围内！" });
                                    }
                                }
                                else
                                {
                                    return Ok(new { code = 2, msg = "未配置评审模块！" });
                                }
                                if (int.TryParse($"{_reviewStatus}", out int reviewStatus))
                                {
                                    contest.review.reviewStatus = reviewStatus;
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(contest, new PartitionKey("Contest"));
                                    return Ok(new { code = 200, msg = "操作成功！" });
                                }
                                else
                                {
                                    return Ok(new { code = 4, msg = "评审参数错误！" });
                                }
                            }
                            else {
                                return Ok(new { code = 3, msg = "活动不存在！" });
                            }
                        }
                    //分配评审作品任务-检查，自动分配
                    case bool when $"{grant_type}".Equals("allocation-task-auto-assign", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            Azure.Response responseReviewRule = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("ReviewRule-disposable"));
                            if (responseReviewRule.Status == 200)
                            {
                                ReviewRule reviewRule = JsonDocument.Parse(responseReviewRule.Content).RootElement.ToObject<ReviewRule>();
                                Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                if (responseContest.Status == 200)
                                {
                                    long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                    Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                    if (contest.modules.Contains("review") && contest.review != null)
                                    {

                                        if (now < contest.review.stime || now > contest.review.etime)
                                        {
                                            return Ok(new { code = 12, msg = "不在评审时间范围内！" });
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 11, msg = "未配置评审模块！" });
                                    }

                                    var result = ActivityService.CheckReviewRule(reviewRule, contest);

                                    if (result.invalidCode == 200)
                                    {
                                        Azure.Response responseActivityExpert = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync($"{_activityId}", new PartitionKey("ActivityExpert"));
                                        if (responseActivityExpert.Status == 200)
                                        {
                                            ActivityExpert activityExpert = JsonDocument.Parse(responseActivityExpert.Content).RootElement.ToObject<ActivityExpert>();

                                         
                                            HashSet<string> periodSubjectKey = new HashSet<string>();
                                            List<dynamic> distributeInvalid = new List<dynamic>();
                                            string allocationTaskKey = $"Contest:Allocation:{_activityId}";
                                            switch (reviewRule.distribute)
                                            {
                                                case "period":
                                                    {
                                                        List<ExpertPeriodSubjectDto> expertPeriodSubjects = new List<ExpertPeriodSubjectDto>();
                                                        var fieldPeriod = contest.sign.fields.Find(z => z.field.Equals("period"));
                                                        if (fieldPeriod == null)
                                                        {
                                                            return Ok(new { code = 5, msg = "评审规则匹配学段，但赛课表单未配置学段。" });
                                                        }
                                                        else
                                                        {
                                                            foreach (string item in fieldPeriod.item)
                                                            {
                                                                periodSubjectKey.Add($"{item}-");
                                                                var periodExperts = activityExpert.experts.Where(z => z.modules.Contains("Contest") && z.subjects != null && z.subjects.Where(v => !string.IsNullOrWhiteSpace(v.period)).Select(c => c.period).Contains(item));
                                                                if (periodExperts.Count() < reviewRule.taskCount)
                                                                {
                                                                    distributeInvalid.Add(new { name = item, expertCount = periodExperts.Count(), needCount = reviewRule.taskCount });
                                                                }
                                                                expertPeriodSubjects.AddRange(periodExperts.Select(z => new ExpertPeriodSubjectDto { expertId = z.id, periodSubjects = z.subjects.Select(x => $"{x.period}-")?.ToList() }));
                                                            }
                                                        }
                                                        if (distributeInvalid.Count > 0)
                                                        {
                                                            return Ok(new { code = 6, msg = "学段匹配的专家数量不足。", distributeInvalid });
                                                        }
                                                        else
                                                        {
                                                            IEnumerable<ExpertPeriodSubjectDto> experts = activityExpert.experts.Where(z => !string.IsNullOrWhiteSpace(z.id))//处理
                                                            .Select(z => new ExpertPeriodSubjectDto { expertId = z.id, expertName=z.iname, expertPicture=z.picture, expertTmdname=z.name, periodSubjects = z.subjects.Select(v => $"{v.period}-") });
                                                            var allocationResult = await ActivityService.AllocationTask(_azureCosmos, experts, contest, periodSubjectKey, reviewRule.distribute, reviewRule.taskCount);
                                                            if (allocationResult.expertContestTasks.IsNotEmpty())
                                                            {
                                                                await _azureRedis.GetRedisClient(8).StringSetAsync(allocationTaskKey, allocationResult.expertContestTasks.ToJsonString(), expiry: new TimeSpan(0, 5, 0));
                                                            }
                                                            else
                                                            {
                                                                allocationTaskKey = string.Empty;
                                                            }
                                                            return Ok(new { taskKey = allocationTaskKey, code = 200, tasksDb = allocationResult.expertContestTasksDB, tasksAdd = allocationResult.expertContestTasks, invalid = allocationResult.activityEnrollsInvalid });
                                                        }
                                                    }
                                                case "subject":
                                                    {
                                                        List<ExpertPeriodSubjectDto> expertPeriodSubjects = new List<ExpertPeriodSubjectDto>();
                                                        var fieldSubject = contest.sign.fields.Find(z => z.field.Equals("subject"));
                                                        if (fieldSubject == null)
                                                        {
                                                            return Ok(new { code = 7, msg = "评审规则匹配学科，但赛课表单未配置学科。" });
                                                        }
                                                        else
                                                        {
                                                            foreach (string item in fieldSubject.item)
                                                            {
                                                                periodSubjectKey.Add($"-{item}");
                                                                var subjectExperts = activityExpert.experts.Where(z => z.modules.Contains("Contest") && z.subjects != null && z.subjects.Where(v => !string.IsNullOrWhiteSpace(v.subject)).Select(c => c.subject).Contains(item));
                                                                if (subjectExperts.Count() < reviewRule.taskCount)
                                                                {
                                                                    distributeInvalid.Add(new { name = item, expertCount = subjectExperts.Count(), needCount = reviewRule.taskCount });
                                                                }
                                                                expertPeriodSubjects.AddRange(subjectExperts.Select(z => new ExpertPeriodSubjectDto { expertId = z.id, periodSubjects = z.subjects.Select(x => $"-{x.subject}")?.ToList() }));
                                                            }
                                                        }
                                                        if (distributeInvalid.Count > 0)
                                                        {
                                                            return Ok(new { code = 8, msg = "学科匹配的专家数量不足。", distributeInvalid });
                                                        }
                                                        else
                                                        {
                                                            IEnumerable<ExpertPeriodSubjectDto> experts = activityExpert.experts.Where(z => !string.IsNullOrWhiteSpace(z.id))//处理
                                                            .Select(z => new ExpertPeriodSubjectDto { expertId = z.id, expertName=z.iname, expertPicture=z.picture, expertTmdname=z.name, periodSubjects = z.subjects.Select(v => $"-{v.subject}") });
                                                            var allocationResult = await ActivityService.AllocationTask(_azureCosmos, experts, contest, periodSubjectKey, reviewRule.distribute, reviewRule.taskCount);
                                                            if (allocationResult.expertContestTasks.IsNotEmpty())
                                                            {
                                                                await _azureRedis.GetRedisClient(8).StringSetAsync(allocationTaskKey, allocationResult.expertContestTasks.ToJsonString(), expiry: new TimeSpan(0, 5, 0));
                                                            }
                                                            else
                                                            {
                                                                allocationTaskKey = string.Empty;
                                                            }
                                                            return Ok(new { taskKey = allocationTaskKey, code = 200, tasksDb = allocationResult.expertContestTasksDB, tasksAdd = allocationResult.expertContestTasks, invalid = allocationResult.activityEnrollsInvalid });
                                                        }
                                                    }

                                                case "periodAndSubject":
                                                    {
                                                        List<ExpertPeriodSubjectDto> expertPeriodSubjects = new List<ExpertPeriodSubjectDto>();
                                                        var fieldPeriod = contest.sign.fields.Find(z => z.field.Equals("period"));
                                                        if (fieldPeriod == null)
                                                        {
                                                            return Ok(new { code = 9, msg = "评审规则匹配学段和学科，但赛课表单未配置学段。" });
                                                        }
                                                        var fieldSubject = contest.sign.fields.Find(z => z.field.Equals("subject"));
                                                        if (fieldSubject == null)
                                                        {
                                                            return Ok(new { code = 10, msg = "评审规则匹配学段和学科，但赛课表单未配置学科。" });
                                                        }
                                                        foreach (var period in fieldPeriod.item)
                                                        {
                                                            foreach (var subject in fieldSubject.item)
                                                            {
                                                                periodSubjectKey.Add($"{period}-{subject}");
                                                                var periodSubjectExperts = activityExpert.experts.FindAll(z => z.modules.Contains("Contest") && z.subjects != null && z.subjects.Where(v => !string.IsNullOrWhiteSpace(v.period) && !string.IsNullOrWhiteSpace(v.subject))
                                                                        .Select(c => $"{c.period}-{c.subject}").Contains($"{period}-{subject}"));
                                                                if (periodSubjectExperts.Count() < reviewRule.taskCount)
                                                                {
                                                                    distributeInvalid.Add(new { name = $"{period}-{subject}", expertCount = periodSubjectExperts.Count(), needCount = reviewRule.taskCount });
                                                                }
                                                                expertPeriodSubjects.AddRange(periodSubjectExperts.Select(z => new ExpertPeriodSubjectDto { expertId = z.id, periodSubjects = z.subjects.Select(x => $"{x.period}-{x.subject}")?.ToList() }));
                                                            }
                                                        }
                                                        if (distributeInvalid.Count > 0)
                                                        {
                                                            return Ok(new { code = 13, msg = "学段和学科匹配的专家数量不足。", distributeInvalid });
                                                        }
                                                        else
                                                        {
                                                            IEnumerable<ExpertPeriodSubjectDto> experts = activityExpert.experts.Where(z => !string.IsNullOrWhiteSpace(z.id))//处理
                                                            .Select(z => new ExpertPeriodSubjectDto { expertId = z.id, expertName=z.iname, expertPicture=z.picture, expertTmdname=z.name, periodSubjects = z.subjects.Select(v => $"{v.period}-{v.subject}") });
                                                            var allocationResult = await ActivityService.AllocationTask(_azureCosmos, experts, contest, periodSubjectKey, reviewRule.distribute, reviewRule.taskCount);
                                                            if (allocationResult.expertContestTasks.IsNotEmpty())
                                                            {
                                                                await _azureRedis.GetRedisClient(8).StringSetAsync(allocationTaskKey, allocationResult.expertContestTasks.ToJsonString(), expiry: new TimeSpan(0, 5, 0));
                                                            }
                                                            else
                                                            {
                                                                allocationTaskKey = string.Empty;
                                                            }
                                                            return Ok(new { taskKey = allocationTaskKey, code = 200, tasksDb = allocationResult.expertContestTasksDB, tasksAdd = allocationResult.expertContestTasks, invalid = allocationResult.activityEnrollsInvalid });

                                                        }
                                                    }
                                                default:
                                                    //distribute=none
                                                    {
                                                        if (activityExpert.experts.Count() >= reviewRule.taskCount)
                                                        {
                                                            periodSubjectKey.Add($"-"); IEnumerable<ExpertPeriodSubjectDto> experts = activityExpert.experts.Where(z => !string.IsNullOrWhiteSpace(z.id))//处理
                                                            .Select(z => new ExpertPeriodSubjectDto { expertId = z.id, expertName=z.iname, expertPicture=z.picture, expertTmdname=z.name, periodSubjects = z.subjects.Select(v => $"-") });

                                                            var allocationResult = await ActivityService.AllocationTask(_azureCosmos, experts, contest, periodSubjectKey, reviewRule.distribute, reviewRule.taskCount);
                                                            if (allocationResult.expertContestTasks.IsNotEmpty())
                                                            {
                                                                await _azureRedis.GetRedisClient(8).StringSetAsync(allocationTaskKey, allocationResult.expertContestTasks.ToJsonString(), expiry: new TimeSpan(0, 5, 0));
                                                            }
                                                            else
                                                            {
                                                                allocationTaskKey = string.Empty;
                                                            }
                                                            return Ok(new { taskKey = allocationTaskKey, code = 200, tasksDb = allocationResult.expertContestTasksDB, tasksAdd = allocationResult.expertContestTasks, invalid = allocationResult.activityEnrollsInvalid });
                                                        }
                                                        else
                                                        {
                                                            return Ok(new { code = 4, msg = "评审专家人数不应少于作品分配次数。" });
                                                        }
                                                    }
                                            }
                                        }
                                        else
                                        {

                                            return Ok(new { code = 3, msg = "未配置评审专家！" });
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = result.invalidCode, msg = result.msg });
                                    }
                                }
                                else
                                {
                                    return Ok(new { code = 2, msg = "没有赛课模块！" });
                                }
                                //专家人数>=每个作品分配次数，同一作品才不会多次被分配到分配给同一个专家。
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "未配置评审规则！" });
                            }

                        }
                    //分配评审作品任务-自动
                    case bool when $"{grant_type}".Equals("allocation-task-auto-save", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("taskKey", out JsonElement _taskKey)) return BadRequest();
                            var value = await _azureRedis.GetRedisClient(8).StringGetAsync(_taskKey.GetString());
                            if (value.HasValue)
                            {
                                List<ExpertContestTaskDto> contestTasks = value.ToString().ToObject<List<ExpertContestTaskDto>>();
                                List<ActivityExpertTask> expertTasks = new List<ActivityExpertTask>();
                                var expertIds = contestTasks.Where(x => !string.IsNullOrWhiteSpace(x.expertId)).Select(z => z.expertId).ToHashSet();
                                if (expertIds != null && expertIds.Count > 0)
                                {
                                    string taskSQL = $"select value c from c where c.pk='ActivityExpertTask' and c.id in ({string.Join(",", expertIds.Select(z => $"'{z}'"))})";
                                  
                                    var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(taskSQL, $"ActivityExpertTask-{_activityId}");
                                    if (result.list.IsNotEmpty())
                                    {
                                        expertTasks.AddRange(result.list);
                                    }
                                }
                                HashSet<ActivityExpertTask> expertTasksChange = new HashSet<ActivityExpertTask>();
                                Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                Contest contest = null;
                                if (responseContest.Status == 200)
                                {
                                    long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                    contest= JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                    if (contest.modules.Contains("review") && contest.review != null)
                                    {

                                        if (now < contest.review.stime || now > contest.review.etime)
                                        {
                                            return Ok(new { code = 12, msg = "不在评审时间范围内！" });
                                        }
                                    }
                                }
                                foreach (var contestTask in contestTasks)
                                {
                                    ExpertContestTask expertContestTask = contestTask.ToJsonString().ToObject<ExpertContestTask>();
                                    var expertTask = expertTasks.Find(z => z.id.Equals(contestTask.expertId));
                                    if (expertTask != null)
                                    {
                                       
                                        var task = expertTask.contestTasks.Find(z => z.uploadId.Equals(contestTask.uploadId));
                                        if (task == null)
                                        {
                                            expertTask.contestTasks.Add(expertContestTask);
                                            expertTasksChange.Add(expertTask);
                                        }
                                    }
                                    else
                                    {

                                        ActivityExpertTask activityExpertTask = new ActivityExpertTask()
                                        {
                                            id = contestTask.expertId,
                                            code = $"ActivityExpertTask-{_activityId}",
                                            pk = "ActivityExpertTask",
                                            activityId=_activityId.GetString(),
                                            picture=contestTask.expertPicture,
                                            name=contestTask.expertName,
                                            tmdname=contestTask.expertTmdname,
                                            contestTasks = new List<ExpertContestTask> { expertContestTask }
                                        };
                                        expertTasksChange.Add(activityExpertTask);
                                        expertTasks.Add(activityExpertTask);
                                    }
                                }
                                List<Task<ItemResponse<ActivityExpertTask>>> responses = new List<Task<ItemResponse<ActivityExpertTask>>>();
                                foreach (var contestTask in expertTasksChange)
                                {
                                    responses.Add(_azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(contestTask, new PartitionKey($"ActivityExpertTask-{_activityId}")));
                                }
                                if (responses.IsNotEmpty())
                                {
                                    await responses.TaskPage(10);
                                    //await Task.WhenAll(responses);
                                }
                                await _azureRedis.GetRedisClient(8).KeyDeleteAsync(_taskKey.GetString());

                                List<ExpertContestTaskDto> tasksDb = new List<ExpertContestTaskDto>();
                                foreach (var item in expertTasks)
                                {
                                    tasksDb.AddRange(item.contestTasks.Select(z =>
                                    new ExpertContestTaskDto
                                    {
                                        expertName=item.name,
                                        expertPicture=item.picture,
                                        expertTmdname=item.tmdname,
                                        expertId = item.id,
                                        available = 1,
                                        uploadId = z.uploadId,
                                        name = z.name,
                                        uploadTypes = z.uploadTypes,
                                        count = z.count,
                                        cipher=z.cipher,
                                        type=z.type,
                                        leader=z.leader,
                                        members=z.members,
                                        tmdid=z.tmdid,
                                        score=z.score,
                                        status=z.status,
                                        detailScore=z.detailScore,

                                        activityId=_activityId.GetString()
                                    }));
                                }
                                return Ok(new { code = 200, tasksDb = tasksDb });
                            }
                            else { return Ok(new { code = 1, msg = "作品分配Token异常！" }); }
                        }
                    //分配评审作品任务-手动
                    case bool when $"{grant_type}".Equals("allocation-task-manual-save", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("uploadId", out JsonElement _uploadId)) return BadRequest();
                            if (!request.TryGetProperty("expertId", out JsonElement _expertId)) return BadRequest();
                            request.TryGetProperty("expertIdOld", out JsonElement _expertIdOld);
                            Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                            if (responseContest.Status == 200) {
                                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                if (contest.modules.Contains("review") && contest.review != null)
                                {

                                    if (now < contest.review.stime || now > contest.review.etime)
                                    {
                                        return Ok(new { code = 12, msg = "不在评审时间范围内！" });
                                    }
                                }
                                else
                                {
                                    return Ok(new { code = 11, msg = "未配置评审模块！" });
                                }
                            }
                            else
                            {
                                return Ok(new { code = 13, msg = "没有赛课模块！" });
                            }

                            string sql = $"select value c from c where c.upload.uploadId='{_uploadId}' and c.pk='ActivityEnroll'";
                            var result =  await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(sql, $"ActivityEnroll-{_activityId}");
                            if (result.list.IsNotEmpty())
                            {
                                ActivityExpertTask expertTask = null;

                                ExpertContestTask contestTask = new ExpertContestTask
                                {
                                    uploadId=_uploadId.GetString(),

                                };
                                string name = string.Empty;
                                int count = 0;
                                if (result.list.Count>1)
                                {
                                    var leaders = result.list.FindAll(z => z.contest.leader == 1);
                                    var leader = leaders?.First();
                                    if (leader!=null)
                                    {
                                        name = leader?.contest?.teamName;
                                        if (string.IsNullOrEmpty(name))
                                        {
                                            name = $"{leader?.contest?.enrollInfos?.Find(z => z.code.Equals("name"))?.val}({result.list.Count})";
                                        }
                                        if (leader?.upload != null && leader.upload.sokrates.IsNotEmpty())
                                        {
                                            count += leader.upload.sokrates.Count;
                                        }
                                        if (leader?.upload != null && leader.upload.files.IsNotEmpty())
                                        {
                                            count += leader.upload.files.Count;
                                        }
                                        if (leader?.upload != null && leader.upload.lessons.IsNotEmpty())
                                        {
                                            count += leader.upload.lessons.Count;
                                        }

                                        if (leader?.upload!=null  && leader.upload.complexes.IsNotEmpty())
                                        {
                                            count+= leader.upload.complexes.Count();
                                        }
                                        List<IdNameCode> members = result.list.Select(z => new IdNameCode { id = z.id, code = z.schoolId, picture = z.tmdPicture, nickname = z.tmdName, name = z.contest?.enrollInfos?.Find(e => e.code.Equals("name")).val }).ToList();
                                        var period = leader?.contest?.enrollInfos?.Find(z => z.code.Equals("period"));
                                        var subject = leader?.contest?.enrollInfos?.Find(z => z.code.Equals("subject"));
                                        contestTask.name= $"{leader?.schoolName}-{name}";
                                        //contestTask.uploadTypes=new List<string> { leader.upload?.type };
                                        contestTask.uploadTypes =leader.upload.uploadType;
                                        contestTask.count=count;
                                        contestTask.cipher=leader.contest?.cipher;
                                        contestTask.type=leader.contest.type;
                                        contestTask.leader=leader.contest.leader;
                                        contestTask.members= members;
                                        contestTask.tmdid=leader.id;
                                        contestTask.period=period?.val;
                                        contestTask.subject=subject?.val;

                                    }
                                    else
                                    {
                                        return Ok(new { code = 3, msg = "该队伍没有队长！" });
                                    }
                                }
                                else if (result.list.Count==1)
                                {
                                    var leader = result.list[0];
                                    name = leader?.contest?.enrollInfos?.Find(z => z.code.Equals("name"))?.val;
                                    if (leader?.upload != null && leader.upload.sokrates.IsNotEmpty())
                                    {
                                        count += leader.upload.sokrates.Count;
                                    }
                                    if (leader?.upload != null && leader.upload.files.IsNotEmpty())
                                    {
                                        count += leader.upload.files.Count;
                                    }
                                    if (leader?.upload != null && leader.upload.lessons.IsNotEmpty())
                                    {
                                        count += leader.upload.lessons.Count;
                                    }
                                    var period = leader?.contest?.enrollInfos?.Find(z => z.code.Equals("period"));
                                    var subject = leader?.contest?.enrollInfos?.Find(z => z.code.Equals("subject"));
                                    contestTask.name= $"{leader?.schoolName}-{name}";
                                    contestTask.uploadTypes= leader.upload.uploadType;
                                    contestTask.count=count;
                                    contestTask.type=leader.contest.type;
                                    contestTask.tmdid=leader.id;
                                    contestTask.period=period?.val;
                                    contestTask.subject=subject?.val;
                                }

                                ActivityExpert activityExpert = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemAsync<ActivityExpert>(_activityId.GetString(), new PartitionKey("ActivityExpert"));
                                Expert expert=  activityExpert.experts.Find(z => !string.IsNullOrWhiteSpace(z.id)  &&   z.id.Equals(_expertId.GetString()));
                                if (expert!=null) {
                                    //作品是否有分配过
                                    string taskSQL = $"select value c from c  join b in c.contestTasks where b.uploadId='{_uploadId}' and c.pk='ActivityExpertTask' " ;
                                    var resultTask = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(taskSQL, $"ActivityExpertTask-{_activityId}");
                                    if (resultTask.list.IsNotEmpty())
                                    {
                                        if (!string.IsNullOrWhiteSpace($"{_expertIdOld}")) {

                                            if (!expert.id.Equals(_expertIdOld.GetString()))
                                            {
                                                //从旧的分配中移除
                                                var oldTaskExpert = resultTask.list.Find(z => z.id.Equals(_expertIdOld.GetString()));
                                                if (oldTaskExpert!=null)
                                                {
                                                    var changeCount = oldTaskExpert.contestTasks.RemoveAll(z => z.uploadId.Equals(_uploadId.GetString()));
                                                    if (changeCount>0)
                                                    {
                                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(oldTaskExpert, new PartitionKey(oldTaskExpert.code));
                                                    }
                                                }
                                                else
                                                {
                                                    return Ok(new { code = 2, msg = "未找到该作品已经分配的专家！" });
                                                }
                                            }
                                            else {
                                                return Ok(new { code = 4, msg = "作品变更评审专家，调整后的专家不能与已分配的专家相同！" });
                                            }
                                        }
                                        // 除去被调整的专家（oldExpert）,（resultTask）可能还有别的专家已分配的，但是不影响该作品继续被分配到新的专家， 可以理解为，作品分配次数+1，
                                        //作品未被分配的情况、
                                        string expTaskSQL = $"select value c from c  where c.id='{expert.id}' and c.pk='ActivityExpertTask' ";
                                        var resultExpTask = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(expTaskSQL, $"ActivityExpertTask-{_activityId}");
                                      
                                        if (resultExpTask.list.IsNotEmpty())
                                        {
                                            var task = resultExpTask.list[0].contestTasks.Find(z => z.uploadId.Equals(_uploadId.GetString()));
                                            if (task!=null)
                                            {
                                                task=contestTask;
                                            }
                                            else
                                            {
                                                resultExpTask.list[0].contestTasks.Add(contestTask);
                                            }
                                            expertTask=resultExpTask.list[0];
                                            expertTask.activityId=_activityId.GetString();
                                        }
                                        else
                                        {
                                            //专家没有任何被分配的作品
                                             expertTask = new ActivityExpertTask()
                                            {
                                                id= expert.id,
                                                code=$"ActivityExpertTask-{_activityId}",
                                                pk="ActivityExpertTask",
                                                ttl=-1,
                                                activityId=_activityId.GetString(),
                                                name=expert.iname,
                                                tmdname=expert.name,
                                                picture=expert.picture,
                                                contestTasks= new List<ExpertContestTask> { contestTask }
                                            };
                                        }
                                        if (expertTask!=null) {
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(expertTask, new PartitionKey(expertTask.code));
                                        }
                                    }
                                    else {
                                        //旧专家，和作品没有匹配的情况，未分配过，不能调整。
                                        if (!string.IsNullOrWhiteSpace($"{_expertIdOld}"))
                                        {
                                            return Ok(new { code = 2, msg = "未找到该作品已经分配的专家！" });
                                        }
                                       
                                        //作品未被分配的情况、
                                        string expTaskSQL = $"select value c from c  where c.id='{expert.id}' and c.pk='ActivityExpertTask' ";
                                        var resultExpTask = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(expTaskSQL, $"ActivityExpertTask-{_activityId}");
                                      
                                        if (resultExpTask.list.IsNotEmpty())
                                        {
                                            var task = resultExpTask.list[0].contestTasks.Find(z => z.uploadId.Equals(_uploadId.GetString()));
                                            if (task!=null)
                                            {
                                                task=contestTask;
                                            }
                                            else {
                                                resultExpTask.list[0].contestTasks.Add(contestTask);
                                            }
                                            expertTask=resultExpTask.list[0];
                                            expertTask.activityId=_activityId.GetString();
                                        }
                                        else {
                                            //专家没有任何被分配的作品

                                            expertTask = new ActivityExpertTask() 
                                            {
                                                id= expert.id,
                                                code=$"ActivityExpertTask-{_activityId}",
                                                pk="ActivityExpertTask",
                                                ttl=-1,
                                                activityId=_activityId.GetString(),
                                                name=expert.iname,
                                                tmdname=expert.name,
                                                picture=expert.picture,
                                                contestTasks= new List<ExpertContestTask> { contestTask }
                                            };
                                        }
                                        if (expertTask!=null)
                                        {
                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(expertTask, new PartitionKey(expertTask.code));
                                        }
                                    }   
                                }
                                return Ok(new { code = 200, expertTask });
                            }
                            else {
                                return Ok(new { code=1,msg ="作品不存在！"});
                            }
                          
                        }
                    //修改活动成绩公示状态
                    case bool when $"{grant_type}".Equals("update-scoreStatus", StringComparison.OrdinalIgnoreCase): 
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("scoreStatus", out JsonElement _scoreStatus)) return BadRequest();
                            Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                            if (responseContest.Status == 200)
                            {
                                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                if (contest.modules.Contains("score") && contest.score != null)
                                {

                                    if (now < contest.score.stime || now > contest.score.etime)
                                    {
                                        return Ok(new { code = 1, msg = "不在成绩公布时间范围内！" });
                                    }
                                }
                                else
                                {
                                    return Ok(new { code = 2, msg = "未配置成绩公布模块！" });
                                }
                                if (int.TryParse($"{_scoreStatus}", out int scoreStatus))
                                {
                                    contest.score.scoreStatus = scoreStatus;
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(contest, new PartitionKey("Contest"));
                                    return Ok(new { code = 200, msg = "操作成功！" });
                                }
                                else
                                {
                                    return Ok(new { code = 4, msg = "成绩公布参数错误！" });
                                }
                            }
                            else
                            {
                                return Ok(new { code = 3, msg = "活动不存在！" });
                            }
                        }
                        //修改活动成绩公布类型或等级
                    case bool when $"{grant_type}".Equals("update-scoreShowTypeOrLevel", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("showType", out JsonElement _showType)) return BadRequest();
                            request.TryGetProperty("attention", out JsonElement _attention);
                            request.TryGetProperty("top", out JsonElement _top);
                            request.TryGetProperty("showDetail", out JsonElement _showDetail);
                            
                            List<ScoreLevel> scoreLevels = new List<ScoreLevel>();
                            bool ok = true;
                            string msg = string.Empty;
                            int code = 200;
                            //全部
                            int showDetail = 0;
                            int top = -1;
                            int levelType = -1;
                            if (int.TryParse($"{_top}", out int topReq)  && topReq>0) 
                            {
                                top=topReq;
                            }
                            if (int.TryParse($"{_showDetail}", out int showDetailReq)) 
                            {
                                showDetail=showDetailReq;
                            }
                            if (int.TryParse($"{_showType}", out int showType))
                            {

                                if (showType==1)
                                {
                                  //  int levelType = 0;
                                    if (!request.TryGetProperty("levelType", out JsonElement _levelType) ||!int.TryParse($"{_levelType}", out  levelType)||!(levelType==0  ||levelType==1))
                                    {
                                        code=7;
                                        ok = false;
                                        msg="等级类型参数错误";
                                    }
                                    else {
                                        if (!request.TryGetProperty("scoreLevels", out JsonElement _scoreLevels))
                                        {
                                            code=1;
                                            ok = false;
                                            msg="等级设置参数错误";
                                        }
                                        else
                                        {
                                            scoreLevels= _scoreLevels.ToObject<List<ScoreLevel>>();
                                            if (scoreLevels.IsNotEmpty())
                                            {
                                                scoreLevels= scoreLevels.OrderBy(z => z.min).ToList();
                                                double max = scoreLevels.First().min;
                                                foreach (ScoreLevel scoreLevel in scoreLevels)
                                                {
                                                    if (levelType==0)
                                                    {
                                                        //检查当前值最大大于最小
                                                        if (scoreLevel.max>scoreLevel.min)
                                                        {   //当前最小大于上一轮的最大值
                                                            if (scoreLevel.min==max)
                                                            {

                                                                max = scoreLevel.max;
                                                            }
                                                            else
                                                            {
                                                                ok=false;
                                                                code=3;
                                                                msg=$"相邻等级的分数设置错误";
                                                                break;
                                                            }
                                                        }
                                                        else
                                                        {
                                                            ok=false;
                                                            code=4;
                                                            msg=$"等级的最大值小于最小值";
                                                            break;
                                                        }
                                                    }
                                                    else {
                                                        if (scoreLevel.top<=0) {
                                                            ok=false;
                                                            code=8;
                                                            msg=$"等级人数必须大于0";
                                                            break;
                                                        }
                                                    }
                                                }

                                            }
                                            else
                                            {
                                                code=2;
                                                ok = false;
                                                msg="分数等级未设置！";
                                            }
                                        }
                                    }
                                    
                                }
                                else if (showType==0)
                                {
                                    ok=true;
                                    code=200;
                                }
                                else
                                {
                                    code=1;
                                    ok = false;
                                    msg="参数错误";
                                }
                            }
                            else
                            {
                                code=1;
                                ok = false;
                                msg="参数错误";
                            }
                            if (code==200 && ok==true)
                            {
                                Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                if (responseContest.Status == 200)
                                {
                                    long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                    Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                    if (contest.modules.Contains("score") && contest.score != null)
                                    {
                                        contest.score.showType=showType;
                                        contest.score.scoreLevels=scoreLevels;
                                        contest.score.attention=$"{_attention}";
                                        contest.score.top=top;
                                        contest.score.levelType=levelType;
                                        contest.score.showDetail=showDetail;
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(contest, new PartitionKey("Contest"));
                                        return Ok(new { code = 200, msg = "操作成功" });
                                    }
                                    else
                                    {
                                        return Ok(new { code = 5, msg = "未配置成绩公布模块！" });
                                    }

                                }
                                else
                                {
                                    return Ok(new { code = 6, msg = "活动不存在！" });
                                }
                            }
                            else {
                                return Ok(new { code, msg });
                            }
                        }
                        //修改分数，在作品公布环节才能调整
                    case bool when $"{grant_type}".Equals("update-maskScore", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            if (!request.TryGetProperty("maskScoreDatas", out JsonElement _maskScoreDatas)) return BadRequest();
                            List<MaskScoreDto> maskScores = _maskScoreDatas.ToObject<List<MaskScoreDto>>();
                            if (maskScores.IsNotEmpty())
                            {
                                Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                if (responseContest.Status == 200)
                                {
                                    long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                    Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                    if (contest.score?.stime<now && contest.score?.etime>now)
                                    {
                                        string sql = $"select value c from c where c.upload.uploadId in ({string.Join(",", maskScores.Select(z => $"'{z.uploadId}'"))}) and  c.pk='ActivityEnroll' ";
                                        var reslut = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(sql, $"ActivityEnroll-{_activityId}");
                                        foreach (var item in maskScores)
                                        {
                                            var enrolls = reslut.list.FindAll(z => z.upload.uploadId.Equals(item.uploadId));
                                            if (enrolls.IsNotEmpty())
                                            {
                                                foreach (var enroll in enrolls)
                                                {
                                                    if (item.showScore==1  && item.maskScore>=0)
                                                    {
                                                        enroll.upload.showScore=item.showScore;
                                                        enroll.upload.maskScore=item.maskScore;
                                                    }
                                                    else
                                                    {
                                                        enroll.upload.showScore=0;
                                                    }
                                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(enroll, new PartitionKey(enroll.code));
                                                }
                                                item.hasError=0;
                                            }
                                            else
                                            {
                                                item.hasError=1;
                                            }
                                        }

                                    }
                                    else
                                    {
                                        return Ok(new { code = 1, msg = "不在作品公布时间范围内！" });
                                    }
                                }
                                else
                                {
                                    return Ok(new { code = 2, msg = "活动不存在！" });
                                }
                            }
                            else {
                                return Ok(new { code = 2, msg = "活动不存在！" });
                            }
                            return Ok(new { code = 200, maskScores });
                        }
                    case bool when $"{grant_type}".Equals("get-scores", StringComparison.OrdinalIgnoreCase): 
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                            if (responseContest.Status == 200)
                            {
                                List<ActivityTeacherScoreMask> teacherScores = new List<ActivityTeacherScoreMask>();
                                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                                if (contest.score?.stime<now)
                                {
                                    string sql = $"select value c from c where  c.pk='ActivityEnroll' ";
                                    var reslut = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(sql, $"ActivityEnroll-{_activityId}");
                                    if (contest.sign.type==1)
                                    {
                                        var teams = reslut.list.Where(x => !string.IsNullOrEmpty(x.contest?.cipher)).GroupBy(z => z.contest.cipher);
                                        foreach (var team in teams)
                                        {
                                            var members = team.ToList();
                                            var leader = members.FindAll(z => z.contest.leader==1)?.FirstOrDefault();
                                            if (leader==null)
                                            {
                                                leader=members.First();
                                            }
                                            teacherScores.Add(new ActivityTeacherScoreMask
                                            {
                                                uploadId=leader.upload?.uploadId,
                                                uploadName=!string.IsNullOrWhiteSpace(leader.upload?.name) ? leader.upload?.name : $"{leader.contest.teamName}",
                                                score=leader.upload?.score??-1,
                                                maskScore=leader.upload?.maskScore??-1,
                                                showScore=leader.upload?.showScore??0,
                                                tmdid=leader.id,
                                                nickname=leader.tmdName,
                                                name=leader.contest.enrollInfos.Find(z => z.code.Equals("name"))?.val,
                                                picture=leader.tmdPicture,
                                                school=leader.schoolId,
                                                schoolName=leader.schoolName,
                                                schoolPicture=leader.schoolPicture,
                                                cipher=leader.contest.cipher,
                                                teamName=leader.contest.teamName,
                                                type=leader.contest.type,
                                                members=members.Select(z => new IdNameCode { id=z.id, name=z.contest.enrollInfos.Find(x => x.code.Equals("name"))?.val, picture=z.tmdPicture, nickname=z.tmdName }).ToList(),
                                            });
                                        }
                                    }
                                    else
                                    {
                                        ///个人组
                                        foreach (var item in reslut.list)
                                        {
                                            teacherScores.Add(new ActivityTeacherScoreMask
                                            {
                                                uploadId=item.upload?.uploadId,
                                                uploadName=!string.IsNullOrWhiteSpace(item.upload?.name) ? item.upload?.name : $"{item.contest.enrollInfos.Find(z => z.code.Equals("name"))?.val}",
                                                score=item.upload?.score??-1,
                                                maskScore=item.upload?.maskScore??-1,
                                                showScore=item.upload?.showScore??0,
                                                tmdid=item.id,
                                                nickname=item.tmdName,
                                                name=item.contest.enrollInfos.Find(z => z.code.Equals("name"))?.val,
                                                picture=item.tmdPicture,
                                                school=item.schoolId,
                                                schoolName=item.schoolName,
                                                schoolPicture=item.schoolPicture,
                                                type=item.contest.type,
                                            });
                                        }
                                    }
                                }
                                return Ok(new { code = 200, teacherScores });
                            }
                            else {
                                return Ok(new { code = 1, msg = "活动不存在" });
                            }
                           
                        }
                    case bool when $"{grant_type}".Equals("preview-scores", StringComparison.OrdinalIgnoreCase): 
                        {
                            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                            List<ActivityScoreLevel> contestScores = await ActivityService.ActivityScores(_azureCosmos,_activityId);
                            return Ok(new { code = 200, contestScores });
                        }
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{ex.Message}\n{ex.StackTrace}\n{request.ToJsonString()}", GroupNames.成都开发測試群組);
                return Ok(new { code = 500, msg = ex.Message });
            }
            return Ok();
        }


        /// <summary>
        /// portal站的
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("login-portal")]
        public async Task<IActionResult> LoginPortal(JsonElement request)
        {
            int timezone = 8;
            if (HttpContext.Request.Headers.TryGetValue("Time-Zone", out var Time_Zone) && int.TryParse(Time_Zone, out int tz))
            {
                timezone=tz;
            }
            string tmdid = null;
            if (!request.TryGetProperty("route", out JsonElement _route)) return BadRequest();
            request.TryGetProperty("ticket", out JsonElement _ticket);
            request.TryGetProperty("token", out JsonElement _token);
            TeacherInfo teacherInfo = null;
            object name = null, picture = null;
            string head_lang = "";
            (string ip, string region) = await LoginService.LoginIp(HttpContext, _searcher);
            if (!string.IsNullOrWhiteSpace($"{_ticket}"))
            {
                var clientID = _configuration.GetValue<string>("HaBookAuth:CoreService:clientID");
                (HttpStatusCode statusCode, CoreAPIToken token) = await _coreAPIHttpService.GetCoreAPIoAuth2Token(
                     new Dictionary<string, object> { { "client_id", clientID }, { "grant_type", "authorization_code" }, { "code", _ticket.GetString() } }, _option.Location, _configuration, _dingDing);
                if (statusCode.Equals(HttpStatusCode.OK))
                {
                    var jwt = new JwtSecurityToken(token.id_token);
                    tmdid = jwt.Payload.Sub;

                    if (HttpContext.Request.Headers.TryGetValue("lang", out var _lang))
                    {
                        head_lang = $"{_lang}";
                    }
                    jwt.Payload.TryGetValue("name", out name);
                    jwt.Payload.TryGetValue("picture", out picture);
                    jwt.Payload.TryGetValue("lang", out object _jwtlang);
                    head_lang = !string.IsNullOrWhiteSpace($"{_jwtlang}") ? $"{_jwtlang}" : head_lang;
                }
            }

            if (tmdid == null)
            {
                if (!string.IsNullOrWhiteSpace($"{_token}"))
                {
                    var jwt = new JwtSecurityToken(_token.GetString());
                    if (JwtAuthExtension.ValidateAuthTokenRefresh(_token.GetString(), _option.JwtSecretKey))
                    {
                        tmdid = jwt.Payload.Sub;

                        if (HttpContext.Request.Headers.TryGetValue("lang", out var _lang))
                        {
                            head_lang = $"{_lang}";
                        }
                        jwt.Payload.TryGetValue("name", out name);
                        jwt.Payload.TryGetValue("picture", out picture);
                        jwt.Payload.TryGetValue("lang", out object _jwtlang);
                        head_lang = !string.IsNullOrWhiteSpace($"{_jwtlang}") ? $"{_jwtlang}" : head_lang;
                    }
                    else { return Ok(new { code = 2, msg = "Token验证失败" }); }
                }
                else { return Ok(new { code = 3, msg = "凭证验证失败" }); }
            }

            teacherInfo = await TeacherService.TeacherInfoLite(_azureCosmos, $"{name}", $"{picture}", tmdid, _azureStorage, _option, _azureRedis, ip, _httpTrigger, head_lang,timezone);
            string sql = $"select value c from c where c.route='{_route}'";
            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).GetList<ActivityWebsite>(sql, "ActivityWebsite");
            ActivityWebsite website = null;
            if (result.list.Count>1)
            {
                return Ok(new { code = 1, msg = "路由匹配多个区校" });
            }
            else
            {
                if (result.list.Count==1)
                {
                    website= result.list[0];

                }
            }
            List<string> roles = new List<string>() { "teacher" };

            CoreUser coreUser = await _coreAPIHttpService.GetUserInfo(new Dictionary<string, string> { { "key", teacherInfo.teacher.id } }, _option.Location, _configuration);
            string sqlExpert = $"select value c from c join e in c.experts   where e.id='{teacherInfo.teacher.id}'";
            if (!string.IsNullOrWhiteSpace(coreUser.mobile))
            {
                sqlExpert=$" {sqlExpert} or  e.mobile='{coreUser.mobile}' ";

            }
            var resultActivityExpert = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpert>(sqlExpert, "ActivityExpert", pageSize: 1);

            if (resultActivityExpert.list.IsNotEmpty())
            {
                roles.Add("expert");
            }
            var payload = new JwtPayload {
                { JwtRegisteredClaimNames.Iss, _option.HostName }, //發行者
                { JwtRegisteredClaimNames.Sub, teacherInfo.teacher.id }, // 用戶ID                  
                { JwtRegisteredClaimNames.Exp,DateTimeOffset.UtcNow.AddHours(2).ToUnixTimeSeconds()},  // 到期的時間，必須為數字
                { "name",name}, // 用戶的顯示名稱
                { "picture",picture}, // 用戶頭像
                { "roles", roles.ToArray()}, // 登入者的角色，角色類型 (Admin、Teacher、Student) 
                { JwtRegisteredClaimNames.Website,website?.route},
            };
            var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_option.JwtSecretKey));
            //var signingCredentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256Signature);
            var signingCredentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
            var header = new JwtHeader(signingCredentials);
            var secToken = new JwtSecurityToken(header, payload);
            // 產出所需要的 JWT securityToken 物件，並取得序列化後的 Token 結果(字串格式)
            var tokenHandler = new JwtSecurityTokenHandler();
            var serializeToken = tokenHandler.WriteToken(secToken);
            var core_clientID = _configuration.GetValue<string>("HaBookAuth:CoreService:clientID");
            var core_clientSecret = _configuration.GetValue<string>("HaBookAuth:CoreService:clientSecret");
            string location = _option.Location;
            if (location.Contains("China"))
            {
                location = "China";
            }
            else if (location.Contains("Global"))
            {
                location = "Global";
            }
            var access_token = await CoreTokenExtensions.CreateAccessToken(core_clientID, core_clientSecret, location);
            return Ok(new { auth_token = new { access_token = access_token.AccessToken, token_type = access_token.TokenType, expires_in = access_token.ExpiresOn }, code = 200, token = serializeToken, schools = teacherInfo.teacher.schools.Where(z => z.status.Equals("join")) });
        }

        [ProducesDefaultResponseType]
        [HttpPost("get-website")]
        public async Task<IActionResult> GetWebsite(JsonElement request)
        {
            if (!request.TryGetProperty("route", out JsonElement _route)) return BadRequest();
            string sql = $"select value c from c where c.route='{_route}'";
            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).GetList<ActivityWebsiteDto>(sql, "ActivityWebsite");
            ActivityWebsiteDto website = null;

            if (result.list.Count>1)
            {
                return Ok(new { code = 1, msg = "路由匹配多个区校" });
            }
            else
            {
                if (result.list.Count==1)
                {
                    website= result.list[0];
                }
                if (result.list.Count==0) {
                    try {
                        Azure.Response responseSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync($"{_route}", new PartitionKey("Base"));
                        if (responseSchool.Status==200)
                        {

                            ActivityWebsite websiteDB = new ActivityWebsite
                            {
                                id=$"{_route}",
                                pk="ActivityWebsite",
                                code="ActivityWebsite",
                                route=$"{_route}",
                                scope="school",
                                allowPublic=0,
                            };
                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).UpsertItemAsync(websiteDB, new PartitionKey(websiteDB.code));
                            website=new ActivityWebsiteDto(websiteDB);
                        }
                    } catch (Exception ex ) { }
                }
            }
            if (website!= null)
            {
                List<ActivityWebsiteDto> websites = new List<ActivityWebsiteDto>();
                if (website.route.Equals("teammodel"))
                {
                    string sqlAll = $"select value c from c where IS_DEFINED(c.route) = true  and c.route<> null  and  c.route<>'' ";
                    var resultAll = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).GetList<ActivityWebsiteDto>(sqlAll, "ActivityWebsite");
                    websites=resultAll.list;
                }
                websites.ForEach(z => {
                    string cnt = z.id;
                    if (z.id.Equals("teammodel"))
                    {
                        cnt="02944f32-f534-3397-ea56-e6f1fc6c3714";
                    }
                    var it = _azureStorage.GetBlobContainerSAS(cnt, BlobContainerSasPermissions.Read);
                    z.sas= it.sas;
                    z.url=it.uri;

                });
                string cnt = website.id;
                if (website.id.Equals("teammodel"))
                {
                    cnt="02944f32-f534-3397-ea56-e6f1fc6c3714";
                }
                var blob = _azureStorage.GetBlobContainerSAS(cnt, BlobContainerSasPermissions.Read);
                website.sas= blob.sas;
                website.url=blob.uri;
                string blobUrl = blob.uri;
                return Ok(new { code = 200, website, websites, blobUrl });
            }
            else
            {
                return Ok(new { code = 2, msg = "未匹配分站" });
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("read-activity")]
        public async Task<IActionResult> ReadActivity(JsonElement request)
        {
            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
            if (response.Status==200)
            {
                ActivityDto activity = JsonDocument.Parse(response.Content).RootElement.ToObject<ActivityDto>();
                if (activity.publish!=1  && activity.publish!=2)
                {
                    return Ok(new { code = 1, msg = "活动未发布！" });
                }
                Contest contest = null;
                ReviewRuleTree reviewRule = null;
                Azure.Response responseContest = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                if (responseContest.Status==200)
                {
                    contest= JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                    if (contest.modules.Contains("review"))
                    {
                        Azure.Response reviewRuleResponse = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("ReviewRule-disposable"));
                        if (reviewRuleResponse.Status==200)
                        {
                            ReviewRule reviewRuleDB = JsonDocument.Parse(reviewRuleResponse.Content).RootElement.ToObject<ReviewRule>();
                            var tree = ActivityService.ListToTree(reviewRuleDB.configs);
                            reviewRule=new ReviewRuleTree
                            {
                                id=reviewRuleDB.id,
                                name= reviewRuleDB.name,
                                owner= reviewRuleDB.owner,
                                sourceName= reviewRuleDB.sourceName,
                                trees=tree,
                                desc=reviewRuleDB.desc,
                                scoreDetail=reviewRuleDB.scoreDetail,
                                scoreRule=reviewRuleDB.scoreRule,
                                distribute=reviewRuleDB.distribute,
                                taskCount=reviewRuleDB.taskCount,
                            };
                        }
                    }
                }
                Training training = null;
                TEAMModelOS.SDK.Models.Research research = null;
                var (blob_uri, blob_sas) = _azureStorage.GetBlobContainerSAS(activity.owner, BlobContainerSasPermissions.Read | BlobContainerSasPermissions.List);
                activity.sas=blob_sas;
                activity.url=blob_uri;
                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                activity.publish=now>activity.etime ? 2 : activity.publish;
                List<ActivityScoreLevel> contestScores = null; 
                if (contest.score!=null  && contest.score.scoreStatus==1  && now>contest.score?.stime  && now<contest.score.etime)
                {
                    contestScores = await ActivityService.ActivityScores(_azureCosmos, _activityId);
                }
                return Ok(new { code = 200, activity, contest, reviewRule, training, research, contestScores });
            }
            else
            {
                return Ok(new { code = 2, msg = "活动不存在" });
            }
        }

        /// <summary>
        /// 获取活动的站点
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-activity-website")]
        public async Task<IActionResult> GetActivityWebsite(JsonElement request)
        {
            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
            if (response.Status==200)
            {
                Activity activity = JsonDocument.Parse(response.Content).RootElement.ToObject<Activity>();

                if (activity.publish!=1  && activity.publish!=2)
                {
                    return Ok(new { code = 1, msg = "活动未发布！" });
                }
                string routeId = "";
                if (activity.scope.Equals("public"))
                {
                    routeId="";
                }
                else
                {
                    routeId=activity.owner;
                }
                Azure.Response responseActivityWebsite = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(routeId, new PartitionKey("ActivityWebsite"));
                ActivityWebsiteDto website = null;
                if (responseActivityWebsite.Status==200)
                {
                    website=JsonDocument.Parse(responseActivityWebsite.Content).RootElement.ToObject<ActivityWebsiteDto>();
                }

                if (website!= null)
                {
                    string cnt = website.id;
                    if (website.id.Equals("teammodel"))
                    {
                        cnt="02944f32-f534-3397-ea56-e6f1fc6c3714";
                    }
                    var blob = _azureStorage.GetBlobContainerSAS(cnt, BlobContainerSasPermissions.Read);
                    website.sas= blob.sas;
                    website.url=blob.uri;

                    return Ok(new { code = 200, website });
                }
                else
                {
                    return Ok(new { code = 2, msg = "未匹配分站" });
                }
            }
            else
            {
                return Ok(new { code = 3, msg = "活动不存在" });
            }
        }

        /// <summary>
        /// 教师在赛课模块的操作
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("expert-contest")]
        [AuthToken(Roles = "expert")]

#if !DEBUG
         [Authorize(Roles = "IES")]
#endif
        public async Task<IActionResult> ExpertContest(JsonElement request)
        {
            (string tmdid, string name, string picture, _) = HttpContext.GetAuthTokenInfo();
            if (!request.TryGetProperty("grant_type", out JsonElement grant_type)) return BadRequest();

            var client = _azureCosmos.GetCosmosClient();

            switch (true)
            { //获取分配的任务
                case bool when $"{grant_type}".Equals("get-enroll-by-uploadId", StringComparison.OrdinalIgnoreCase):
                    {
                        if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                        if (!request.TryGetProperty("uploadId", out JsonElement _uploadId)) return BadRequest();
                        string enrollSQL = $"select value c from c where c.activityId='{_activityId.GetString()}' and c.upload.uploadId='{_uploadId}' ";
                        //不是自己的，且学校不为空，则查询指定学校的，否则获取所有报名的数据
                        var enrollResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(enrollSQL, $"ActivityEnroll-{_activityId}");
                        EnrollUpload upload = null; 
                        if (enrollResult.list.IsNotEmpty()) {
                            upload= enrollResult.list[0].upload;
                        }
                        return Ok(new { upload });
                    }
                //获取分配的任务
                case bool when $"{grant_type}".Equals("list-task", StringComparison.OrdinalIgnoreCase):
                    {
                        List<ActivityExpertDto> activities = new List<ActivityExpertDto>();
                        long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                        //在时间内正在进入评审阶段的活动。
                        string contestSQL = $"select value c from c where c.review.stime<={now} and c.review.etime>={now} and c.review.reviewStatus=1";
                        var contestResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Contest>(contestSQL, "Contest");
                        if (contestResult.list.IsNotEmpty()) 
                        {
                            string baseSQL = $"select value c from c where c.id in ({string.Join(",", contestResult.list.Select(z => $"'{z.id}'"))}) ";
                            var activityResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(baseSQL, "Activity");
                            string sql = $"select value c  from c where  c.activityId in ({string.Join(",", contestResult.list.Select(z => $"'{z.id}'"))})  and  c.id='{tmdid}' and  c.pk='ActivityExpertTask'";
                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(sql);
                            foreach (var item in result.list)
                            {
                                var contest =  contestResult.list.Find(z => z.id.Equals(item.activityId));
                                var activity = activityResult.list.Find(z => z.id.Equals(item.activityId));
                                var (blob_uri, blob_sas) = _azureStorage.GetBlobContainerSAS(activity.owner, BlobContainerSasPermissions.Read | BlobContainerSasPermissions.List);

                                activities.Add(new ActivityExpertDto
                                {
                                    activityId=item.activityId,
                                    activityName=activity?.name,
                                    stime=contest?.review?.stime??0,
                                    etime=contest?.review?.etime??0,
                                    taskCount=item.contestTasks.Count(),
                                    completeCount=item.contestTasks.Where(z => z.status==1).Count(),
                                    contestTasks=item.contestTasks,
                                    sas=blob_sas,
                                    url=blob_uri
                                    
                                }) ;
                            }
                        }
                        return Ok(new { activities,code=200 });
                    }
                ///评分
                case bool when $"{grant_type}".Equals("decide-score", StringComparison.OrdinalIgnoreCase):
                    {
                        if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
                        if (!request.TryGetProperty("scoreData", out JsonElement _scoreData)) return BadRequest();
                        Azure.Response response = await client.GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                        if (response.Status==200)
                        {
                            long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                            Contest contest = JsonDocument.Parse(response.Content).RootElement.ToObject<Contest>();
                            if (contest.review!= null   &&contest.review.stime<now &&contest.review.etime>now)
                            {
                                if (contest.review.reviewStatus==1)
                                {
                                    //作品安分配次数，如果分数全部打完成，自动汇算 
                                    ReviewScoreData scoreData=  _scoreData.ToObject<ReviewScoreData>();
                                    var ruleResponse=  await client.GetContainer(Constant.TEAMModelOS, Constant.Normal).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("ReviewRule-disposable"));
                                    ReviewRule reviewRule = JsonDocument.Parse(ruleResponse.Content).RootElement.ToObject<ReviewRule>();
                                    if (reviewRule.scoreDetail==1) {
                                        if (!scoreData.detailScore.IsNotEmpty()) 
                                        {
                                            return Ok(new { code = 5, msg = "需要进行细项评分！" });
                                        }
                                    }
                                    if (scoreData.score<0) {
                                        return Ok(new { code = 6, msg = "分数不能小于0！" });
                                    }
                                    if (!string.IsNullOrWhiteSpace(scoreData.uploadId))
                                    {
                                        ActivityExpertTask expertTask = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemAsync<ActivityExpertTask>(tmdid, new PartitionKey($"ActivityExpertTask-{_activityId}"));
                                        var task = expertTask.contestTasks.Find(x => x.uploadId.Equals(scoreData.uploadId));
                                        task.score = scoreData.score;
                                        task.status=1;
                                        task.detailScore = ActivityService.TreeToList(scoreData.detailScore, new List<RuleConfig>()) ;
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(expertTask, new PartitionKey($"ActivityExpertTask-{_activityId}"));
                                        //检查作品是否完成评审自动结算
                                        {
                                            string sql = $"select distinct  value  c  from c join b in c.contestTasks  where c.activityId='{_activityId}' and b.uploadId='{scoreData.uploadId}'";
                                            var uploadAllResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(sql, $"ActivityExpertTask-{_activityId}");
                                            if (uploadAllResult.list.IsNotEmpty()) 
                                            {
                                                var unfinish = uploadAllResult.list.SelectMany(x=>x.contestTasks).Where(z => z.status!=1  && z.uploadId.Equals(scoreData.uploadId));
                                                if (!(unfinish!=null  && unfinish.Count()>0)) {
                                                    //没有未完成的评审作品自动结算、
                                                    string enrollSQL =$"select value c from c where c.upload.uploadId='{scoreData.uploadId}'and c.pk ='ActivityEnroll' ";
                                                    var enrollResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(enrollSQL, $"ActivityEnroll-{_activityId}");
                                                    foreach (var item in enrollResult.list) 
                                                    {
                                                        bool change = false;
                                                        List<ExpertUploadScore> expertScores= new List<ExpertUploadScore>();
                                                        foreach (var expertScore  in uploadAllResult.list)
                                                        {
                                                            var taskScore = expertScore.contestTasks.Find(z => z.uploadId.Equals(item.upload.uploadId));
                                                            if (taskScore!= null) {
                                                                expertScores.Add(new ExpertUploadScore {
                                                                    id= expertScore.id,
                                                                    name=expertScore.name,
                                                                    score=taskScore.score,
                                                                    detailScore=taskScore.detailScore
                                                                });
                                                            }
                                                        }
                                                        switch (reviewRule.scoreRule) 
                                                        {
                                                            case "only":
                                                                if (expertScores.IsNotEmpty() && expertScores.Count==1) 
                                                                { 
                                                                    item.upload.score= expertScores.First().score;
                                                                    change=true;
                                                                }
                                                                break;
                                                            case "avg":
                                                                if (expertScores.IsNotEmpty()  && expertScores.Count>=2)
                                                                {
                                                                    item.upload.score= expertScores.Average(z => z.score); 
                                                                    change=true;
                                                                }
                                                                break;
                                                            case "top":
                                                                if (expertScores.IsNotEmpty() && expertScores.Count>2) {
                                                                    item.upload.score= expertScores.Max(z => z.score);
                                                                    change=true;
                                                                }
                                                                break;
                                                            case "rmLowAvg":
                                                                if (expertScores.IsNotEmpty() && expertScores.Count>=3) 
                                                                {
                                                                    expertScores.Remove(expertScores.Min());
                                                                    if (expertScores.IsNotEmpty()) {
                                                                        item.upload.score= expertScores.Average(z => z.score);
                                                                        change=true;
                                                                    }
                                                                }
                                                                break;
                                                            case "rmTopAvg":
                                                                if (expertScores.IsNotEmpty() && expertScores.Count>=3)
                                                                {
                                                                    expertScores.Remove(expertScores.Max());
                                                                    if (expertScores.IsNotEmpty())
                                                                    {
                                                                        item.upload.score= expertScores.Average(z => z.score);
                                                                        change=true;
                                                                    }
                                                                }
                                                                break;
                                                            case "rmLowTopAvg":
                                                                if (expertScores.IsNotEmpty() && expertScores.Count>=4)
                                                                {
                                                                    expertScores.Remove(expertScores.Max());
                                                                    expertScores.Remove(expertScores.Min());
                                                                    if (expertScores.IsNotEmpty())
                                                                    {
                                                                        item.upload.score= expertScores.Average(z => z.score);
                                                                        change=true;
                                                                    }
                                                                }
                                                                break;
                                                        }
                                                        if (change)
                                                        {
                                                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(item, new PartitionKey($"ActivityEnroll-{_activityId}"));
                                                        }
                                                      
                                                    }
                                                }
                                            }
                                        }
                                        return Ok(new { code = 200, completeCount = expertTask.contestTasks.Where(z => z.status==1).Count(), contestTasks = expertTask.contestTasks });
                                    }
                                    else
                                    {
                                        return Ok(new { code = 4, msg = "参数错误！" });
                                    }
                                }
                                else
                                {
                                    return Ok(new { code = 2, msg = "评审已关闭！" });
                                }
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "已过评审时间！" });
                            }
                        }
                        else {
                            return Ok(new { code = 3, msg = "活动不存在！" });
                        }
                    }
            }
            return Ok();
        }

            /// <summary>
            /// 教师在赛课模块的操作
            /// </summary>
            /// <param name="request"></param>
            /// <returns></returns>
            [ProducesDefaultResponseType]
        [HttpPost("teacher-contest")]
        [AuthToken(Roles = "teacher")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif
        public async Task<IActionResult> TeacherContest(JsonElement request)
        {
            (string tmdid, string name, string picture, _) = HttpContext.GetAuthTokenInfo();
            if (!request.TryGetProperty("grant_type", out JsonElement grant_type)) return BadRequest();

            if ($"{grant_type}".Equals("update-teacher-enroll"))
            {

                if (!request.TryGetProperty("teacherEnroll", out JsonElement _teacherEnroll))
                {
                    return Ok(new { code = 0, msg = "报名信息未完善！" });
                };
                TeacherEnroll teacherEnroll = _teacherEnroll.ToObject<TeacherEnroll>();
                teacherEnroll.id=tmdid;
                teacherEnroll.code="TeacherEnroll";
                teacherEnroll.pk="TeacherEnroll";
                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(teacherEnroll, new PartitionKey("TeacherEnroll"));
                return Ok(new { code = 200, teacherEnroll });
            }
            if ($"{grant_type}".Equals("get-teacher-enroll"))
            {
                TeacherEnroll teacherEnroll = null;
                Azure.Response responseTeacherEnroll= await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(tmdid, new PartitionKey("TeacherEnroll"));
                if (responseTeacherEnroll.Status==200)
                {
                    teacherEnroll= JsonDocument.Parse(responseTeacherEnroll.Content).RootElement.ToObject<TeacherEnroll>();
                    return Ok(new { code = 200, teacherEnroll });
                }
                else {
                    return Ok(new { code = 1, msg="未填写" });
                }
               
            }

            if (!request.TryGetProperty("activityId", out JsonElement _activityId)) return BadRequest();
            var client = _azureCosmos.GetCosmosClient();
            Azure.Response response = await client.GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Activity"));
            Azure.Response responseContest = await client.GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
            try
            {
                if (response.Status==200)
                {
                    int code = -1;
                    long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                    Activity activity = JsonDocument.Parse(response.Content).RootElement.ToObject<Activity>();
                    Contest contest = null;

                    if (responseContest.Status==200)
                    {
                        contest=JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();
                    }
                    else
                    {
                        return Ok(new { code = 33, msg = "未设置赛课模块！" });
                    }
                    if (!activity.modules.Contains("Contest"))
                    {
                        return Ok(new { code = 33, msg = "未设置赛课模块！" });
                    }
                    if (activity.publish>=1)
                    {
                        //如果包含了评审模块
                        if (contest.modules.Contains("review"))
                        {
                            if (contest.review!=null)
                            {
                                if (now>= contest.review?.stime  &&  !$"{grant_type}".Equals("get-enroll", StringComparison.OrdinalIgnoreCase))
                                {
                                    //只能查看报名信息
                                    return Ok(new { code = 35, msg = "已到截至日期，不能操作！" });
                                }
                            }
                            else
                            {
                                return Ok(new { code = 34, msg = "评审模块信息未完善！" });
                            }
                        }
                        switch (true)
                        {
                            //移除队员
                            case bool when $"{grant_type}".Equals("remove-member", StringComparison.OrdinalIgnoreCase):
                                {
                                    if (!request.TryGetProperty("removeMember", out JsonElement _removeMember)) return BadRequest();
                                    if (tmdid.Equals(_removeMember.GetString()))
                                    {
                                        return Ok(new { code = 5, msg = "不能移除自己！" });
                                    }
                                    Azure.Response responseActivityEnroll = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(tmdid, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                    if (responseActivityEnroll.Status==200)
                                    {
                                        ActivityEnroll enrollOld = JsonDocument.Parse(responseActivityEnroll.Content).RootElement.ToObject<ActivityEnroll>();
                                        if (enrollOld!=null  && enrollOld?.contest?.leader==1  && enrollOld?.contest?.type==1)
                                        {
                                            Azure.Response responseActivityEnrollRemove = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(_removeMember.GetString(), new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                            if (responseActivityEnrollRemove.Status==200)
                                            {
                                                ActivityEnroll enrollRemove = JsonDocument.Parse(responseActivityEnrollRemove.Content).RootElement.ToObject<ActivityEnroll>();
                                                if (enrollRemove!=null  && enrollRemove?.contest!=null && enrollOld?.contest?.type==1)
                                                {
                                                    if (enrollOld.contest.cipher.Equals(enrollRemove.contest.cipher))
                                                    {
                                                        enrollRemove.contest.cipher=null;
                                                        //string cipher = await ActivityService.GenCipher(client, _dingDing, _option, _activityId.GetString());
                                                        await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(enrollRemove, new PartitionKey(enrollRemove.code));
                                                        return Ok(new { code = 200, msg = "移除成功！" });
                                                    }
                                                    else
                                                    {
                                                        return Ok(new { code = 4, msg = "指定的队长不是同一团队人员！" });
                                                    }
                                                }
                                                else
                                                {
                                                    return Ok(new { code = 3, msg = "指定的队长未参加本次活动！" });
                                                }
                                            }
                                            else
                                            {
                                                return Ok(new { code = 3, msg = "指定的队长未参加本次活动！" });
                                            }
                                        }
                                        else
                                        {
                                            return Ok(new { code = 1, msg = "你不是队长！" });
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "你未参加本次活动！" });
                                    }
                                }
                            ///移交队长
                            case bool when $"{grant_type}".Equals("change-team-leader", StringComparison.OrdinalIgnoreCase):
                                {
                                    if (!request.TryGetProperty("targetLeader", out JsonElement _targetLeader)) return BadRequest();
                                    if (tmdid.Equals(_targetLeader.GetString()))
                                    {
                                        return Ok(new { code = 5, msg = "不能将队长移交给自己！" });
                                    }
                                    Azure.Response responseActivityEnroll = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(tmdid, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                    if (responseActivityEnroll.Status==200)
                                    {
                                        ActivityEnroll enrollOld = JsonDocument.Parse(responseActivityEnroll.Content).RootElement.ToObject<ActivityEnroll>();
                                        if (enrollOld!=null  && enrollOld?.contest?.leader==1  && enrollOld?.contest?.type==1)
                                        {
                                            Azure.Response responseActivityEnrollNew = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(_targetLeader.GetString(), new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                            if (responseActivityEnrollNew.Status==200)
                                            {
                                                ActivityEnroll enrollNew = JsonDocument.Parse(responseActivityEnrollNew.Content).RootElement.ToObject<ActivityEnroll>();
                                                if (enrollNew!=null  && enrollNew?.contest!=null && enrollOld?.contest?.type==1)
                                                {
                                                    if (enrollOld.contest.cipher.Equals(enrollNew.contest.cipher))
                                                    {
                                                        enrollOld.contest.leader=0;
                                                        enrollNew.contest.leader=1;
                                                        await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(enrollNew, new PartitionKey(enrollNew.code));
                                                        await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(enrollOld, new PartitionKey(enrollOld.code));
                                                        return Ok(new { code = 200, msg = "移交成功！" });
                                                    }
                                                    else
                                                    {
                                                        return Ok(new { code = 4, msg = "指定的队长不是同一团队人员！" });
                                                    }
                                                }
                                                else
                                                {
                                                    return Ok(new { code = 3, msg = "指定的队长未参加本次活动！" });
                                                }
                                            }
                                            else
                                            {
                                                return Ok(new { code = 3, msg = "指定的队长未参加本次活动！" });
                                            }
                                        }
                                        else
                                        {
                                            return Ok(new { code = 1, msg = "你不是队长！" });
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "你未参加本次活动！" });
                                    }
                                }
                            ///取消报名
                            case bool when $"{grant_type}".Equals("cancel-enroll", StringComparison.OrdinalIgnoreCase):
                                {

                                    ActivityEnroll enroll = null;
                                    Azure.Response responseActivityEnroll = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(tmdid, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                    if (responseActivityEnroll.Status==200)
                                    {
                                        enroll= JsonDocument.Parse(responseActivityEnroll.Content).RootElement.ToObject<ActivityEnroll>();
                                        if (enroll.contest!=null  && enroll.contest.leader==1)
                                        {
                                            // 如果没有其他队员，则可以直接退出
                                            //检查是否还有其他成员
                                            string cipherSQL = $"select value  c.id  from c where c.contest!=null  and c.activityId='{_activityId.GetString()}' and c.contest.type=1 and  c.contest.cipher='{enroll.contest.cipher}' and c.id<>'{tmdid}' ";
                                            var cipherResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<string>(cipherSQL, $"ActivityEnroll-{_activityId}");
                                            if (cipherResult.list.Count>0)
                                            {
                                                return Ok(new { code = 3, msg = "队伍中还有其他参赛队员,请移交队长后或移除队员后再退出参赛！" });
                                            }
                                        }
                                        Azure.Response responseActivityEnrollDel = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).DeleteItemStreamAsync(enroll.id, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                        if (activity.joinMode.Equals("invite"))
                                        {
                                            string sqlInvite = $"select value c from c join t in c.inviteTeachers where   t.id='{tmdid}' and  c.pk='ActivityTeacher'";
                                            var activityTeacherResult = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityTeacher>(sqlInvite, $"ActivityTeacher-{_activityId}");
                                            foreach (var activityTeacher in activityTeacherResult.list)
                                            {
                                                activityTeacher.inviteTeachers.ForEach(z =>
                                                {
                                                    if (z.id.Equals(tmdid))
                                                    {
                                                        z.status=0;
                                                    }
                                                });
                                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityTeacher, new PartitionKey($"ActivityTeacher-{_activityId}"));
                                            }
                                        }
                                        //已分配作品，强制删除。
                                        if (!string.IsNullOrWhiteSpace(enroll.upload?.uploadId)) 
                                        {
                                            string sql = $"select value c from c join t in c.contestTasks where t.uploadId='{enroll.upload.uploadId}' and c.pk='ActivityExpertTask' ";
                                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(sql, $"ActivityExpertTask-{_activityId}");
                                            if (result.list.IsNotEmpty())
                                            {
                                                foreach (var activityExpertTask in result.list)
                                                {
                                                    await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).DeleteItemStreamAsync(activityExpertTask.id, new PartitionKey(activityExpertTask.code));
                                                }
                                            }
                                        }
                                       
                                        if (responseActivityEnrollDel.Status==204)
                                        {
                                            return Ok(new { code = 204, msg = "退出成功！" });
                                        }
                                        else
                                        {
                                            return Ok(new { code = 2, msg = "退出失败！" });
                                        }
                                    }
                                    return Ok(new { code = 1, msg = "暂无报名数据！", });


                                }
                            ///获取报名
                            case bool when $"{grant_type}".Equals("get-enroll", StringComparison.OrdinalIgnoreCase):
                                {
                                    ActivityEnroll enroll = null;
                                    Azure.Response responseActivityEnroll = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(tmdid, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                    if (responseActivityEnroll.Status==200)
                                    {
                                        //更新邀请状态
                                        if (activity.joinMode.Equals("invite"))
                                        {
                                            string sqlInvite = $"select value c from c join t in c.inviteTeachers where   t.id='{tmdid}' and  c.pk='ActivityTeacher' and t.status=0 ";
                                            var activityTeacherResult = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityTeacher>(sqlInvite, $"ActivityTeacher-{_activityId}");
                                            foreach (var activityTeacher in activityTeacherResult.list)
                                            {
                                                activityTeacher.inviteTeachers.ForEach(z =>
                                                {
                                                    if (z.id.Equals(tmdid))
                                                    {
                                                        z.status=1;
                                                    }
                                                });
                                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityTeacher, new PartitionKey($"ActivityTeacher-{_activityId}"));
                                            }
                                        }
                                        enroll= JsonDocument.Parse(responseActivityEnroll.Content).RootElement.ToObject<ActivityEnroll>();
                                        
                                        double score = -1;
                                        int levelStatus = -1;
                                        string scoreLevel = string.Empty;
                                        int showType = -1;
                                        //是否已经分配作品 0未分配 1 已分配
                                        int allotStatus = 0;
                                        List<dynamic> detailScore = new List<dynamic>();
                                        if (contest.score!=null  && contest.score.scoreStatus==1  && now>contest.score?.stime  && now<contest.score.etime  && enroll.upload!=null)
                                        {
                                            score=enroll.upload.score;
                                            if (enroll.upload.showScore==1) {
                                                score=enroll.upload.maskScore;
                                            }
                                            List<ActivityScoreLevel> contestScores = await ActivityService.ActivityScores(_azureCosmos, _activityId, enroll.id);
                                            var levels = contestScores.SelectMany(x => x.scores).Where(x => x.tmdid.Equals(enroll.id));
                                            ActivityTeacherScoreLevel level = null;
                                            if (level!=null  && levels.Count()>0)
                                            {
                                                level=levels.First();
                                                levelStatus=1;
                                                scoreLevel=level.scoreLevel;
                                                score= level.score;
                                            }
                                            else {
                                                levelStatus=0;
                                            }
                                            showType=contest.score.showType;
                                            
                                        }
                                        if (!string.IsNullOrWhiteSpace(enroll.upload?.uploadId)) 
                                        {
                                            string sql = $"select value c from c join t in c.contestTasks where t.uploadId='{enroll.upload.uploadId}' and c.pk='ActivityExpertTask' ";
                                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(sql, $"ActivityExpertTask-{_activityId}");
                                            if (result.list.IsNotEmpty())
                                            {
                                                if (contest.score!=null &&   contest.score.showDetail==1)
                                                {
                                                    result.list.ForEach(x => {
                                                        var upload = x.contestTasks.Find(z => z.uploadId.Equals(enroll.upload.uploadId));
                                                        if (upload!= null)
                                                        {
                                                            detailScore.Add(new { upload.detailScore, x.id, name = "***" });
                                                        }
                                                    });
                                                }
                                                allotStatus=1;
                                            }
                                        }
                                        
                                        if (enroll.upload!=null) {
                                            enroll.upload.score=-1;
                                            enroll.upload.maskScore=-1;
                                        }
                                        
                                        return Ok(new { code = 200, enroll,scoreData=new { allotStatus, levelStatus , score, scoreLevel, showType, detailScore } });
                                    }
                                    return Ok(new { code = 1, msg = "暂无报名数据！", });

                                }
                            //生成组队口令
                            case bool when $"{grant_type}".Equals("gen-cipher", StringComparison.OrdinalIgnoreCase):
                                {
                                    //Azure.Response responseContest = await client.GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                    //if (responseContest.Status==200   && activity.modules.Contains("Contest"))
                                    //{
                                    //    Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();

                                    //}
                                    if (contest.modules.Contains("sign") && contest.sign!=null  && contest.sign.type==1)
                                    {
                                        string cipher = await ActivityService.GenCipher(client, _dingDing, _option, _activityId.GetString());
                                        return Ok(new { code = 200, cipher });
                                    }
                                    return Ok(new { code = 1, msg = "组队口令生成失败！" });
                                }
                            //根据口令获取团队和队员信息
                            case bool when $"{grant_type}".Equals("search-team-by-cipher", StringComparison.OrdinalIgnoreCase):
                                {
                                    if (!request.TryGetProperty("cipher", out JsonElement _cipher)) return BadRequest();

                                    //Azure.Response responseContest = await client.GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                    //if (responseContest.Status==200   && activity.modules.Contains("Contest"))
                                    //{
                                    //    Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();

                                    //}
                                    if (contest.modules.Contains("sign") && contest.sign!=null  && contest.sign.type==1)
                                    {
                                        string cipherSQL = $"select value  c from c where c.contest!=null  and c.activityId='{_activityId}' and c.contest.type=1 and  c.contest.cipher='{_cipher}' ";
                                        var cipherResult = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(cipherSQL, $"ActivityEnroll-{_activityId}");
                                        List<TeacherEnrollContestDto> teamMembers = new List<TeacherEnrollContestDto>();
                                        teamMembers= cipherResult.list.Select(z => new TeacherEnrollContestDto
                                        {
                                            tmdid= z.id,
                                            tmdPicture= z.tmdPicture,
                                            tmdName= z.tmdName,
                                            schoolName=z.schoolName,
                                            schoolPicture= z.schoolPicture,
                                            schoolId= z.schoolId,
                                            cipher= z.contest.cipher,
                                            enrollTime= z.contest.enrollTime,
                                            leader= z.contest.leader,
                                            teamName= z.contest.teamName,
                                            type=z.contest.type,
                                            enrollInfos= z.contest.enrollInfos
                                        }).ToList();
                                        return Ok(new
                                        {
                                            code = 200,
                                            teamMembers = teamMembers.Select(z => new
                                            {
                                                z.tmdid,
                                                z.tmdPicture,
                                                z.tmdName,
                                                z.schoolName,
                                                z.schoolPicture,
                                                z.schoolId,
                                                z.cipher,
                                                z.enrollTime,
                                                z.leader,
                                                z.teamName,
                                                z.type,
                                                z.enrollInfos
                                            })
                                        });
                                    }
                                    return Ok(new { code = 1, msg = "未找到团队！" });
                                }
                            //教师报名参加
                            case bool when $"{grant_type}".Equals("sign-contest", StringComparison.OrdinalIgnoreCase):
                                {
                                    request.TryGetProperty("mock", out JsonElement _mock);
                                    if (!request.TryGetProperty("enrollData", out JsonElement _enrollData))
                                    {
                                        return Ok(new { code = 0, msg = "报名信息未完善！" });
                                    };
                                    TeacherEnrollContestDto enrollData = _enrollData.ToObject<TeacherEnrollContestDto>();
                                    if (!string.IsNullOrWhiteSpace($"{_mock}")) {
                                        tmdid= enrollData.tmdid;
                                    }
                                    ActivityEnroll enroll = null;
                                    Azure.Response responseActivityEnroll = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(tmdid, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                    if (responseActivityEnroll.Status==200)
                                    {
                                        enroll= JsonDocument.Parse(responseActivityEnroll.Content).RootElement.ToObject<ActivityEnroll>();
                                    }
                                    //邀请制

                                    List<ActivityTeacher> activityTeachers = new List<ActivityTeacher>();
                                    if (activity.joinMode.Equals("invite"))
                                    {
                                        string sqlInvite = $"select value c from c join t in c.inviteTeachers where   t.id='{tmdid}' and  c.pk='ActivityTeacher'";
                                        var activityTeacherResult = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityTeacher>(sqlInvite, $"ActivityTeacher-{_activityId}");
                                        if (activityTeacherResult.list.IsNotEmpty())
                                        {
                                            activityTeachers.AddRange(activityTeacherResult.list);
                                            var exsit = activityTeacherResult.list.Exists(z => z.id.Equals(enrollData.schoolId));
                                            if (!exsit)
                                            {
                                                code=16;
                                                return Ok(new { code, msg = "填报的学校与邀请的学校不一致！" });
                                            }
                                            else
                                            {
                                                code=200;
                                            }
                                        }
                                        else
                                        {
                                            code=1;
                                            return Ok(new { code, msg = "教师未被邀请" });
                                        }
                                    }
                                    //如果邀请制没有检查通过，则检查其他模式
                                    if (code!=200)
                                    {
                                        //如果是 活动主办方设置了 部分学校参加（包含区级以及公开，选择了学校的）
                                        if (activity.invitedSchools.IsNotEmpty() && activity.confirmedSchools.IsNotEmpty())
                                        {
                                            if (!string.IsNullOrWhiteSpace(enrollData.schoolId))
                                            {
                                                if (!activity.invitedSchools.Exists(z => z.id.Equals(enrollData.schoolId)))
                                                {
                                                    return Ok(new { code = 3, msg = "学校未被邀请参与本次活动！" });
                                                }
                                                if (!activity.confirmedSchools.Exists(z => z.id.Equals(enrollData.schoolId)  && z.status==1))
                                                {
                                                    return Ok(new { code = 4, msg = "学校未确认参与本次活动！" });
                                                }
                                                code=200;
                                            }
                                            else
                                            {
                                                return Ok(new { code = 2, msg = "请以学校教师身份参加本次活动！" });
                                            }
                                        }
                                        //完全开放的
                                        else if (activity.scope.Equals("public")  && activity.invitedSchools.IsEmpty())
                                        {
                                            code=200;
                                        }
                                        else if (activity.scope.Equals("school"))
                                        {
                                            if (!string.IsNullOrWhiteSpace(enrollData.schoolId))
                                            {
                                                if (activity.owner.Equals(enrollData.schoolId))
                                                {
                                                    code=200;
                                                }
                                                else
                                                {
                                                    return Ok(new { code = 5, msg = "不是本校的教师不能参加本次活动！" });
                                                }
                                            }
                                            else { return Ok(new { code = 2, msg = "请以学校教师身份参加本次活动！" }); }
                                        }
                                        else if (activity.scope.Equals("area")  && activity.confirmedSchools.IsNotEmpty()) {
                                            if (!string.IsNullOrWhiteSpace(enrollData.schoolId))
                                            {
                                                if (!activity.confirmedSchools.Exists(z => z.id.Equals(enrollData.schoolId)  && z.status==1))
                                                {
                                                    return Ok(new { code = 4, msg = "学校未确认参与本次活动！" });
                                                }
                                                else {
                                                    code=200;
                                                }
                                            }
                                            else { return Ok(new { code = 2, msg = "请以学校教师身份参加本次活动！" }); }
                                        }
                                        else
                                        {
                                            await _dingDing.SendBotMsg($"{_option.Location},活动类型错误：{activity.id}", GroupNames.成都开发測試群組);
                                            return Ok(new { code = 6, msg = "活动类型错误！" });
                                        }
                                    }
                                    if (code==200)
                                    {
                                        ///检查被报名的活动是是否符合
                                        if (activity.publish==1)
                                        {
                                            //Azure.Response responseContest = await client.GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                            //if (responseContest.Status==200   && activity.modules.Contains("Contest"))
                                            //{
                                            //    Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();

                                            //}
                                            //else
                                            //{
                                            //    return Ok(new { code = 14, msg = "活动未设置赛课模块！" });
                                            //}
                                            if (contest.modules.Contains("sign") && contest.sign!=null)
                                            {
                                                //报名时间检查
                                                if (contest.sign.stime<=now  && contest.sign.etime>=now)
                                                {
                                                    code=200;
                                                }
                                                else
                                                {
                                                    return Ok(new { code = 7, msg = "不在报名时间范围内！" });
                                                }
                                                //检查报名人数
                                                if (contest.sign.limit>0)
                                                {
                                                    //报名人数，除去自己
                                                    string countEnrollSQL = $"select value  c.id from c where c.contest!=null  and c.activityId='{_activityId.GetString()}' and c.id<>'{tmdid}' ";
                                                    var countEnrollResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<string>(countEnrollSQL, $"ActivityEnroll-{_activityId.GetString()}");
                                                    if (countEnrollResult.list.Count+1>contest.sign.limit)
                                                    {
                                                        return Ok(new { code = 8, msg = "已超过报名人数限制！" });
                                                    }
                                                    else { code=200; }
                                                }
                                                //检查团队组，检查口令
                                                int checkTeam = -1;
                                                int cipherChange = -1;
                                                if (contest.sign.type==1)
                                                {
                                                    if (enrollData.type==1  && !string.IsNullOrWhiteSpace(enrollData.cipher))
                                                    {

                                                        //检查组队口令
                                                        string cipherSQL = $"select value  c  from c where c.contest!=null  and c.activityId='{_activityId.GetString()}' and c.contest.type=1 and  c.contest.cipher='{enrollData.cipher}' and c.contest.leader=1 ";
                                                        var cipherResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(cipherSQL, $"ActivityEnroll-{_activityId}");
                                                        if (cipherResult.list.IsNotEmpty())
                                                        {
                                                            //如果队伍存在
                                                            if (!cipherResult.list.First().schoolId.Equals(enrollData.schoolId))
                                                            {
                                                                return Ok(new { code = 18, msg = "报名选择的学校与组队学校不一致！" });
                                                            }
                                                            enrollData.teamName= cipherResult.list.First().contest?.teamName;
                                                        }
                                                        if (enrollData.leader==1)
                                                        {
                                                            //队长
                                                            if (cipherResult.list.IsNotEmpty())
                                                            {
                                                                //组队口令已被其他团队使用,此处已顺便处理成员篡位的逻辑
                                                                var otherTeam = cipherResult.list.FindAll(z => !z.id.Equals(tmdid));
                                                                if (otherTeam.IsNotEmpty())
                                                                {
                                                                    return Ok(new { code = 10, msg = "组队口令已被其他团队使用！" });
                                                                }
                                                                else
                                                                {
                                                                    //队长更改信息。
                                                                    //检查 更新信息的 组队口令是否有变化，如果有变化则队员的组队口令也跟着变化
                                                                    if (!string.IsNullOrWhiteSpace(enroll?.contest?.cipher)  && !enroll.contest.cipher.Equals(enrollData.cipher))
                                                                    {
                                                                        cipherChange=1;
                                                                    }
                                                                    checkTeam=1;
                                                                }
                                                            }
                                                            else
                                                            {
                                                                //队长更改信息。
                                                                //检查 更新信息的 组队口令是否有变化，如果有变化则队员的组队口令也跟着变化
                                                                if (!string.IsNullOrWhiteSpace(enroll?.contest?.cipher)  &&    !enroll.contest.cipher.Equals(enrollData.cipher))
                                                                {
                                                                    cipherChange=1;
                                                                }
                                                                checkTeam=1;
                                                            }
                                                        }
                                                        else
                                                        {
                                                            //队长跑路
                                                            if (enroll!=null  && enroll.contest!=null && enroll.contest.leader==1 && enrollData.leader==0)
                                                            {
                                                                return Ok(new { code = 17, msg = "你是队长，不能变更身份！" });
                                                            }

                                                            //队员
                                                            if (cipherResult.list.IsNotEmpty())
                                                            {
                                                                if (cipherResult.list.Count==1)
                                                                {
                                                                    checkTeam=1;
                                                                }
                                                                else
                                                                {
                                                                    await _dingDing.SendBotMsg($"{_option.Location},组队口令重复:{enrollData.cipher}", GroupNames.成都开发測試群組);
                                                                    return Ok(new { code = 12, msg = "组队口令重复！" });
                                                                }
                                                            }
                                                            else
                                                            {
                                                                return Ok(new { code = 11, msg = "队伍未组建或不存在！" });
                                                            }
                                                        }
                                                    }
                                                    else
                                                    {
                                                        return Ok(new { code = 9, msg = "参加组别不一致！" });
                                                    }
                                                }
                                                else
                                                {
                                                    //个人组
                                                    if (contest.sign.type== enrollData.type)
                                                    {
                                                        checkTeam=1;
                                                    }
                                                    else
                                                    {
                                                        return Ok(new { code = 9, msg = "参加组别不一致！" });
                                                    }
                                                }

                                                if (checkTeam==1)
                                                {
                                                    if (enroll!=null)
                                                    {
                                                        //更新组队信息
                                                        enroll.contest.teamName= enrollData.teamName;
                                                        enroll.contest.cipher=enrollData.cipher;
                                                        enroll.contest.type=enrollData.type;
                                                        enroll.contest.leader=enrollData.leader;
                                                        enroll.contest.enrollInfos=enrollData.enrollInfos;
                                                        enroll.contest.enrollTime=now;
                                                        enroll.schoolPicture=enrollData.schoolPicture;
                                                        enroll.schoolId=enrollData.schoolId;
                                                        enroll.schoolName=enrollData.schoolName;
                                                        enroll.tmdName=enrollData.tmdName;
                                                        enroll.tmdPicture=enrollData.tmdPicture;

                                                    }
                                                    else
                                                    {
                                                        enroll= new ActivityEnroll
                                                        {
                                                            id=tmdid,
                                                            schoolName=enrollData.schoolName,
                                                            schoolId=enrollData.schoolId,
                                                            schoolPicture=enrollData.schoolPicture,
                                                            activityId=_activityId.GetString(),
                                                            code=$"ActivityEnroll-{_activityId}",
                                                            pk="ActivityEnroll",
                                                            tmdName=enrollData.tmdName,
                                                            tmdPicture=enrollData.tmdPicture,
                                                            contest=new EnrollContest
                                                            {
                                                                cipher=enrollData.cipher,
                                                                leader=enrollData.leader,
                                                                teamName=enrollData.teamName,
                                                                type=enrollData.type,
                                                                enrollTime=now,
                                                                enrollInfos=enrollData.enrollInfos
                                                            }
                                                        };
                                                    }
                                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(enroll, new PartitionKey(enroll.code));
                                                    List<TeacherEnrollContestDto> teamMembers = new List<TeacherEnrollContestDto>();
                                                    //获取组队队员信息
                                                    if (enrollData.type==1  && !string.IsNullOrWhiteSpace(enrollData.cipher))
                                                    {
                                                        //获取队员报名信息
                                                        string cipherSQL = $"select value  c  from c where c.contest!=null  and c.activityId='{_activityId.GetString()}' and c.contest.type=1 and  c.contest.cipher='{enrollData.cipher}' ";
                                                        var cipherResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(cipherSQL, $"ActivityEnroll-{_activityId}");
                                                        if (cipherChange==1)
                                                        {
                                                            //队长更新其他队员的组队口令
                                                            cipherResult.list.RemoveAll(z => z.contest.leader==1);
                                                            foreach (var z in cipherResult.list)
                                                            {
                                                                z.contest.cipher=enrollData.cipher;
                                                                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(z, new PartitionKey(z.code));
                                                            }
                                                        }
                                                        teamMembers= cipherResult.list.Select(z => new TeacherEnrollContestDto
                                                        {
                                                            tmdid= z.id,
                                                            tmdPicture= z.tmdPicture,
                                                            tmdName= z.tmdName,
                                                            schoolName=z.schoolName,
                                                            schoolPicture= z.schoolPicture,
                                                            schoolId= z.schoolId,
                                                            cipher= z.contest.cipher,
                                                            enrollTime= z.contest.enrollTime,
                                                            leader= z.contest.leader,
                                                            teamName= z.contest.teamName,
                                                            type=z.contest.type,
                                                            enrollInfos= z.contest.enrollInfos,
                                                        }).ToList();
                                                    }
                                                    foreach (var activityTeacher in activityTeachers)
                                                    {
                                                        //反向更新邀请状态
                                                        activityTeacher.inviteTeachers.ForEach(z => { if (z.id.Equals(enrollData.tmdid)) { z.status=1; } });
                                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityTeacher, new PartitionKey($"ActivityTeacher-{_activityId}"));
                                                    }
                                                    return Ok(new
                                                    {
                                                        code = 200,
                                                        enroll,
                                                        teamMembers = teamMembers.Select(z => new
                                                        {
                                                            z.tmdid,
                                                            z.tmdPicture,
                                                            z.tmdName,
                                                            z.schoolName,
                                                            z.schoolPicture,
                                                            z.schoolId,
                                                            z.cipher,
                                                            z.enrollTime,
                                                            z.leader,
                                                            z.teamName,
                                                            z.type,
                                                            z.enrollInfos
                                                        })
                                                    });
                                                }
                                                else
                                                {
                                                    return Ok(new { code = 12, msg = "报名组别检查未通过！" });
                                                }
                                            }
                                            else
                                            {
                                                return Ok(new { code = 15, msg = "活动未设置信息填报模块！" });
                                            }
                                        }
                                        else
                                        {
                                            return Ok(new { code = 13, msg = "活动未发布！" });
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 6, msg = "活动类型错误！" });
                                    }

                                }
                            //作品上传
                            case bool when $"{grant_type}".Equals("upload-contest", StringComparison.OrdinalIgnoreCase):
                                {
                                    request.TryGetProperty("mock", out JsonElement _mock);
                                    if (!request.TryGetProperty("uploadData", out JsonElement _uploadData))
                                    {
                                        return Ok(new { code = 0, msg = "上传信息未完善！" });
                                    };

                                    TeacherUploadContestDto uploadContest = _uploadData.ToObject<TeacherUploadContestDto>();
                                    if (!string.IsNullOrWhiteSpace($"{_mock}"))
                                    {
                                        tmdid= uploadContest.tmdid;
                                    }
                                    if (contest.modules.Contains("upload") && contest.upload!=null)
                                    {
                                        int check = -1;
                                        //作品上传时间
                                        if (!(contest.upload.stime<=now  && contest.upload.etime>=now))
                                        {
                                            return Ok(new { code = 4, msg = "未到上传作品时间！" });
                                        }

                                        ActivityEnroll enroll = null;
                                        int captainUpload = -1;
                                        Azure.Response responseActivityEnroll = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(tmdid, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                        if (responseActivityEnroll.Status==200)
                                        {

                                            enroll= JsonDocument.Parse(responseActivityEnroll.Content).RootElement.ToObject<ActivityEnroll>();
                                            if (contest.modules.Contains("sign"))
                                            {
                                                if (enroll.contest==null)
                                                {
                                                    return Ok(new { code = 2, msg = "请先报名后再上传作品！" });
                                                }
                                                else
                                                {
                                                    if (contest.upload.captainUpload==1)
                                                    {
                                                        if (enroll.contest.type==1)
                                                        {
                                                            if (enroll.contest.leader!=1)
                                                            {
                                                                return Ok(new { code = 3, msg = "作品上传要求队长上传！" });
                                                            }
                                                            else
                                                            {
                                                                check=1;
                                                                captainUpload=1;
                                                            }
                                                        }
                                                        else
                                                        {
                                                            return Ok(new { code = 3, msg = "作品上传要求队长上传！" });
                                                        }
                                                    }
                                                    else
                                                    {
                                                        check=1;
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                //没有报名模块，直接上传
                                                check=1;
                                            }
                                        }
                                        else
                                        {
                                            if (contest.modules.Contains("sign"))
                                            {
                                                return Ok(new { code = 2, msg = "请先报名后再上传作品！" });
                                            }
                                            else
                                            {
                                                //没有报名模块，直接上传
                                                check=1;
                                                enroll= new ActivityEnroll
                                                {
                                                    id=tmdid,
                                                    code=$"ActivityEnroll-{_activityId}",
                                                    pk="ActivityEnroll",
                                                    schoolId= uploadContest.schoolId,
                                                    schoolName=uploadContest.schoolName,
                                                    schoolPicture=uploadContest.schoolPicture,
                                                    activityId=_activityId.GetString()
                                                };
                                            }
                                        }
                                        if (check==1)
                                        {
                                            if (uploadContest.complexes.IsNotEmpty())
                                            {
                                                if (contest.upload.limit>0)
                                                {
                                                    if (contest.upload.limit<contest.upload.uploadType.Count())
                                                    {
                                                        ///上传类型数量限制小于文件类型数量，表示可以上传任意N种类型的文件。
                                                        if (uploadContest.complexes.Count>=contest.upload.limit  && uploadContest.complexes.Count<= contest.upload.uploadType.Count())
                                                        {
                                                            var types = uploadContest.complexes.Select(x => x.type).ToHashSet();
                                                            foreach (var type in types)
                                                            {
                                                                if (!contest.upload.uploadType.Contains(type))
                                                                {
                                                                    return Ok(new { code = 7, msg = "上传的文件类型与活动要求的文件类型不符！" });
                                                                }
                                                            }
                                                        }
                                                        else
                                                        {
                                                            return Ok(new { code = 10, msg = "文件上传数量不满足活动要求上传的文件类型数量！" });
                                                        }
                                                    }
                                                    else
                                                    {
                                                        ///上传类型数量限制大于等于则表示需要上传所有类型的文件。
                                                        if (uploadContest.complexes.Count== contest.upload.uploadType.Count())
                                                        {
                                                            var types = uploadContest.complexes.Select(x => x.type).ToHashSet();
                                                            bool hasError = false;
                                                            foreach (var type in contest.upload.uploadType)
                                                            {
                                                                if (!contest.upload.uploadType.Contains(type))
                                                                {
                                                                    hasError=true;
                                                                }
                                                            }
                                                            if (hasError)
                                                            {
                                                                return Ok(new { code = 7, msg = "上传的文件类型与活动要求的文件类型不符！" });
                                                            }
                                                        }
                                                        else
                                                        {
                                                            return Ok(new { code = 10, msg = "文件上传数量不满足活动要求上传的文件类型数量！" });
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    ///在上传类型范围内，不限制上传文件的种类和类型的数量。
                                                    var types = uploadContest.complexes.Select(x => x.type).ToHashSet();
                                                    foreach (var type in types)
                                                    {
                                                        if (!contest.upload.uploadType.Contains(type))
                                                        {
                                                            return Ok(new { code = 7, msg = "上传的文件类型与活动要求的文件类型不符！" });
                                                        }
                                                    }
                                                }
                                                ///检查必须上传的类型
                                                if (contest.upload.uploadTypeNecessary!=null  && contest.upload.uploadTypeNecessary.Count>0)
                                                {

                                                    var types = uploadContest.complexes.Select(x => x.type).ToHashSet();
                                                    foreach (var type in contest.upload.uploadTypeNecessary)
                                                    {
                                                        if (!types.Contains(type))
                                                        {
                                                            return Ok(new { code = 9, msg = "没有上传活动要求必须上传的文件类型！" });

                                                        }
                                                    }
                                                }
                                                //覆盖更新
                                                enroll.upload= new EnrollUpload
                                                {
                                                    uploadTime=now,
                                                    complexes=uploadContest.complexes,
                                                    uploadType=uploadContest.complexes.Select(x => x.type).ToHashSet(),
                                                    //作品id变更，已经上传过不会发生变更。
                                                    uploadId=string.IsNullOrWhiteSpace(enroll?.upload?.uploadId) ? Guid.NewGuid().ToString(): enroll.upload.uploadId,
                                                    name=uploadContest.name,
                                                };
                                                await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(enroll, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                                if (captainUpload==1&& !string.IsNullOrWhiteSpace(enroll.contest.cipher))
                                                {
                                                    //获取队员报名信息
                                                    string cipherSQL = $"select value  c  from c where c.contest!=null  and c.activityId='{_activityId.GetString()}' and c.contest.type=1 and  c.contest.cipher='{enroll.contest.cipher}' ";
                                                    var cipherResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(cipherSQL, $"ActivityEnroll-{_activityId}");
                                                    //队长统一上传
                                                    cipherResult.list.RemoveAll(z => z.contest.leader==1);
                                                    foreach (var z in cipherResult.list)
                                                    {
                                                        z.upload=enroll.upload;
                                                        //队长统一上传的作品不需要单独生成作品id.
                                                        // z.upload.uploadId=Guid.NewGuid().ToString();
                                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(z, new PartitionKey(z.code));
                                                    }
                                                }
                                                return Ok(new { code = 200, });
                                            }
                                            else
                                            {
                                                return Ok(new { code = 6, msg = "未通过作品验证！" });
                                            }



                                            //if (contest.upload.type.Equals(uploadContest.type))
                                            //{
                                            //    if (uploadContest.type.Equals("sokrates"))
                                            //    {
                                            //        //校验苏格拉底

                                            //        //var httpClient = _httpClientFactory.CreateClient();
                                            //        //if (!httpClient.DefaultRequestHeaders.Contains("x-functions-key"))
                                            //        //{
                                            //        //    httpClient.DefaultRequestHeaders.Add("x-functions-key", "2BcXFR_hvzG1pZjqIkaM7Dx74Hcu6m0PwwOacFpDpq44AzFuHJBRXA==");
                                            //        //}
                                            //        //string paramJson = JsonConvert.SerializeObject(new { fmt = "0" });
                                            //        //var content = new StringContent(paramJson, Encoding.UTF8, "application/json");
                                            //        //HttpResponseMessage httpResponse = await httpClient.PostAsync("https://malearn.teammodel.cn/api/txtwc", content);
                                            //        //if (httpResponse.IsSuccessStatusCode)
                                            //        //{
                                            //        //    string str = await httpResponse.Content.ReadAsStringAsync();
                                            //        //}
                                            //        //  处理队长统一上传
                                            //        return Ok(new { code = 200 });
                                            //    }
                                            //    else if (uploadContest.type.Equals("lesson"))
                                            //    {
                                            //        foreach (var ext in uploadContest.lessons.Select(z => z.extension).ToHashSet())
                                            //        {
                                            //            if (!contest.upload.fileType.Contains(ext))
                                            //            {
                                            //                return Ok(new { code = 7, msg = "上传的文件类型与活动要求的文件类型不符！" });
                                            //            }
                                            //        }
                                            //        //覆盖更新
                                            //        enroll.upload= new EnrollUpload
                                            //        {
                                            //            uploadTime=now,
                                            //            lessons=uploadContest.lessons,
                                            //            type=uploadContest.type,
                                            //            uploadId=Guid.NewGuid().ToString(),
                                            //            name=uploadContest.name,
                                            //        };
                                            //        await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(enroll, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                            //        if (captainUpload==1&& !string.IsNullOrWhiteSpace(enroll.contest.cipher))
                                            //        {
                                            //            //获取队员报名信息
                                            //            string cipherSQL = $"select value  c  from c where c.contest!=null  and c.activityId='{_activityId.GetString()}' and c.contest.type=1 and  c.contest.cipher='{enroll.contest.cipher}' ";
                                            //            var cipherResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(cipherSQL, $"ActivityEnroll-{_activityId}");
                                            //            //队长统一上传
                                            //            cipherResult.list.RemoveAll(z => z.contest.leader==1);
                                            //            foreach (var z in cipherResult.list)
                                            //            {
                                            //                z.upload=enroll.upload;
                                            //                //队长统一上传的作品不需要单独生成作品id.
                                            //                // z.upload.uploadId=Guid.NewGuid().ToString();
                                            //                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(z, new PartitionKey(z.code));
                                            //            }
                                            //        }
                                            //        return Ok(new { code = 200, });
                                            //    }
                                            //    else if (uploadContest.type.Equals("file"))
                                            //    {
                                            //        foreach (var ext in uploadContest.files.Select(z => z.extension).ToHashSet())
                                            //        {
                                            //            if (!contest.upload.fileType.Contains(ext))
                                            //            {
                                            //                return Ok(new { code = 7, msg = "上传的文件类型与活动要求的文件类型不符！" });
                                            //            }
                                            //        }
                                            //        //覆盖更新
                                            //        enroll.upload= new EnrollUpload
                                            //        {
                                            //            uploadTime=now,
                                            //            files=uploadContest.files,
                                            //            type=uploadContest.type,
                                            //            uploadId=Guid.NewGuid().ToString(),
                                            //            name=uploadContest.name,
                                            //        };
                                            //        await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(enroll, new PartitionKey($"ActivityEnroll-{_activityId.GetString()}"));
                                            //        if (captainUpload==1&& !string.IsNullOrWhiteSpace(enroll.contest.cipher))
                                            //        {
                                            //            //获取队员报名信息
                                            //            string cipherSQL = $"select value  c  from c where c.contest!=null  and c.activityId='{_activityId.GetString()}' and c.contest.type=1 and  c.contest.cipher='{enroll.contest.cipher}' ";
                                            //            var cipherResult = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityEnroll>(cipherSQL, $"ActivityEnroll-{_activityId}");
                                            //            //队长统一上传
                                            //            cipherResult.list.RemoveAll(z => z.contest.leader==1);
                                            //            foreach (var z in cipherResult.list)
                                            //            {
                                            //                z.upload=enroll.upload;
                                            //                //队长统一上传的作品不需要单独生成作品id.
                                            //                // z.upload.uploadId=Guid.NewGuid().ToString();
                                            //                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(z, new PartitionKey(z.code));
                                            //            }
                                            //        }
                                            //        return Ok(new { code = 200, });
                                            //    }
                                            //    else
                                            //    {
                                            //        return Ok(new { code = 8, msg = "上传类型不一致！" });
                                            //    }
                                            //}
                                            //else
                                            //{
                                            //    return Ok(new { code = 5, msg = "上传的作品类型与活动要求的作品类型不符！" });
                                            //}
                                        }
                                        else
                                        {
                                            return Ok(new { code = 6, msg = "未通过作品验证！" });
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 1, msg = "未设置上传模块！" });
                                    }
                                    //Azure.Response responseContest = await client.GetContainer(Constant.TEAMModelOS, Constant.Common).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("Contest"));
                                    //if (responseContest.Status==200   && activity.modules.Contains("Contest"))
                                    //{
                                    //    Contest contest = JsonDocument.Parse(responseContest.Content).RootElement.ToObject<Contest>();

                                    //}
                                    //else { return Ok(new { code = 1, msg = "未设置上传模块！" }); }
                                }

                        }
                    }
                    else
                    {
                        return Ok(new { code = 31, msg = "活动未发布！" });
                    }
                }
                else { return Ok(new { code = 32, msg = "活动不存在！" }); }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{_option.Location},报名信息{ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest(ex.Message);
            }
            return Ok();
        }





        /// <summary>
        /// portal站的
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("list-portal")]
        public async Task<IActionResult> ListPortal(JsonElement request)
        {
            //var authtoken = HttpContext.GetXAuth("AuthToken");
            //string userid = string.Empty;
            //object schoolid = null;
            //if (!string.IsNullOrWhiteSpace(authtoken)) {
            //    var jwt = new JwtSecurityToken(authtoken);
            //    //TODO 此驗證IdToken先簡單檢查，後面需向Core ID新API，驗證Token
            //    userid= jwt.Payload.Sub;
            //    jwt.Payload.TryGetValue("azp", out schoolid);
            //}
            if (!request.TryGetProperty("route", out JsonElement _route)) return BadRequest();
            List<ActivityDto> activities = new List<ActivityDto>();
            string sql = $"select value c from c where c.route='{_route}'";
            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).GetList<ActivityWebsite>(sql, "ActivityWebsite");
            ActivityWebsite website = null;
            if (result.list.Count>1)
            {
                return Ok(new { code = 1, msg = "路由匹配多个区校" });
            }
            else
            {
                if (result.list.Count==1)
                {
                    website= result.list[0];
                }
            }

            if (website!=null)
            {
                if (website.scope.Equals("area"))
                {
                    //区级所有学校
                    string sqlOpen = $"select value c from c  where c.scope='area' and (c.publish=1 or c.publish=2 )  and  c.owner='{website.id}'   ";
                    var resultOpen = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<ActivityDto>(sqlOpen, "Activity");
                    activities.AddRange(resultOpen.list);
                }
                if (website.scope.Equals("school"))
                {
                    School schoolbase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(website.id, new PartitionKey("Base"));
                    //区级下放的
                    if (!string.IsNullOrWhiteSpace(schoolbase.areaId))
                    {
                        //区级所有学校
                        string sqlOpen = $"select value c from c join s in c.confirmedSchools where c.scope='area' and (c.publish=1 or c.publish=2 )  and  c.owner='{schoolbase.areaId}'  and( ARRAY_LENGTH(c.invitedSchools)=0 or IS_DEFINED(c.invitedSchools) = false) and s.id='{schoolbase.id}' and s.status=1 ";
                        var resultOpen = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<ActivityDto>(sqlOpen, "Activity");
                        activities.AddRange(resultOpen.list);
                        //区级部分学校
                        string sqlSchool = $"select value c from c  join i in c.invitedSchools join s in c.confirmedSchools  where c.scope='area'and (c.publish=1 or c.publish=2 )  and  c.owner='{schoolbase.areaId}' and i.id='{schoolbase.id}'    and s.id='{schoolbase.id}' and s.status=1 ";
                        var resultSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<ActivityDto>(sqlSchool, "Activity");
                        activities.AddRange(resultSchool.list);
                    }
                    {
                        ///学校自己的 
                        string sqlSchool = $"select value c from c where c.scope='school' and (c.publish=1 or c.publish=2 )  and  c.owner='{schoolbase.id}'  ";
                        var resultSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<ActivityDto>(sqlSchool, "Activity");
                        activities.AddRange(resultSchool.list);
                    }
                }
                //获取开放的
                {
                    //完全开放 所有的学校
                    string sqlOpen = $"select value c from c where c.scope='public' and (c.publish=1 or c.publish=2 )  ";
                    var resultOpen = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<ActivityDto>(sqlOpen, "Activity");
                    activities.AddRange(resultOpen.list);
                }
            }
            long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
            activities.ForEach(z =>
            {
                var (blob_uri, blob_sas) = _azureStorage.GetBlobContainerSAS(z.owner, BlobContainerSasPermissions.Read);
                z.sas=blob_sas;
                z.url=blob_uri;
                if (z.etime<now) {
                    z.publish=2;
                }
            });
            return Ok(new { activities, website });
        }
    }
}