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;
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>();
                                bool checkReviewStime = false;
                                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                //需要检查评审时间
                                if (contest.modules.Contains("review") && contest.review!= null  && now<contest.review.stime)
                                {
                                    checkReviewStime = true;
                                }
                                if (_contestUpdate.TryGetProperty("signStime", out JsonElement signStime)  && signStime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    if (checkReviewStime)
                                    {
                                        if (contest.modules.Contains("sign")  && contest.sign!= null)
                                        {
                                            contest.sign.stime=signStime.GetInt64();
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "已经开始评审！" });
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("signEtime", out JsonElement signEtime)  && signEtime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    if (checkReviewStime)
                                    {
                                        if (contest.modules.Contains("sign")  && contest.sign!= null)
                                        {
                                            contest.sign.etime=signEtime.GetInt64();
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "已经开始评审！" });
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("limit", out JsonElement limit)  && limit.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    if (checkReviewStime)
                                    {
                                        if (contest.modules.Contains("sign")  && contest.sign!= null)
                                        {
                                            contest.sign.limit=limit.GetInt32();
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "已经开始评审！" });
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("uploadStime", out JsonElement uploadStime)  && uploadStime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    if (checkReviewStime)
                                    {
                                        if (contest.modules.Contains("upload")  && contest.upload!= null)
                                        {
                                            contest.upload.stime=uploadStime.GetInt64();
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "已经开始评审！" });
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("uploadEtime", out JsonElement uploadEtime)  && uploadEtime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    if (checkReviewStime)
                                    {
                                        if (contest.modules.Contains("upload")  && contest.upload!= null)
                                        {
                                            contest.upload.etime=uploadEtime.GetInt64();
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "已经开始评审！" });
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("updateDesc", out JsonElement desc)  && desc.ValueKind.Equals(JsonValueKind.String))
                                {
                                    if (checkReviewStime)
                                    {
                                        if (contest.modules.Contains("upload")  && contest.upload!= null)
                                        {
                                            contest.upload.desc=desc.GetString();
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "已经开始评审！" });
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("fileType", out JsonElement fileType)  && fileType.ValueKind.Equals(JsonValueKind.Array))
                                {
                                    if (checkReviewStime)
                                    {
                                        if (contest.modules.Contains("upload")  && contest.upload!= null)
                                        {
                                            if (contest.upload.fileType.IsNotEmpty())
                                            {
                                                contest.upload.fileType=fileType.ToObject<List<string>>();
                                            }
                                        }
                                    }
                                    else
                                    {
                                        return Ok(new { code = 2, msg = "已经开始评审！" });
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("reviewStime", out JsonElement reviewStime)  && reviewStime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    //评审时间不能早于作品上传结束时间的处理
                                    if (contest.modules.Contains("review")  && contest.review!= null)
                                    {
                                        if (contest.modules.Contains("upload") &&contest.upload!= null)
                                        {
                                            if (contest.upload.etime<reviewStime.GetInt64())
                                            {
                                                contest.review.stime=reviewStime.GetInt64();
                                            }
                                            else
                                            {
                                                return Ok(new { code = 3, msg = "评审时间不能早于作品上传时间！" });
                                            }
                                        }
                                        else
                                        {
                                            return Ok(new { code = 4, msg = "未设置作品上传模块！" });
                                        }
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("reviewEtime", out JsonElement reviewEtime)  && reviewEtime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    //评审时间不能早于作品上传结束时间的处理
                                    if (contest.modules.Contains("review")  && contest.review!= null)
                                    {
                                        if (contest.modules.Contains("upload") &&contest.upload!= null)
                                        {
                                            if (contest.upload.etime<reviewEtime.GetInt64()   && contest.review.stime<reviewEtime.GetInt64())
                                            {
                                                contest.review.etime=reviewEtime.GetInt64();
                                            }
                                            else
                                            {
                                                return Ok(new { code = 3, msg = "评审时间不能早于作品上传结束时间！" });
                                            }
                                        }
                                        else
                                        {
                                            return Ok(new { code = 4, msg = "未设置作品上传模块！" });
                                        }
                                    }
                                }
                                if (_contestUpdate.TryGetProperty("scoreStime", out JsonElement scoreStime)  && scoreStime.ValueKind.Equals(JsonValueKind.Number))
                                {
                                    //评审时间不能早于作品上传结束时间的处理
                                    if (contest.modules.Contains("score")  && contest.score!= null)
                                    {
                                        if (contest.modules.Contains("review") &&contest.review!= null)
                                        {
                                            if (contest.review.etime<scoreStime.GetInt64())
                                            {
                                                contest.score.stime=scoreStime.GetInt64();
                                            }
                                            else
                                            {
                                                return Ok(new { code = 5, msg = "作品公布时间不能早于作品评审结束时间！" });
                                            }
                                        }
                                        else
                                        {
                                            return Ok(new { code = 6, msg = "未设置作品评审模块！" });
                                        }
                                    }

                                }
                                if (_contestUpdate.TryGetProperty("scoreEtime", out JsonElement scoreEtime)  && scoreEtime.ValueKind.Equals(JsonValueKind.Number))
                                {  //评审时间不能早于作品上传结束时间的处理
                                    if (contest.modules.Contains("score")  && contest.score!= null)
                                    {
                                        if (contest.modules.Contains("review") &&contest.review!= null)
                                        {
                                            if (contest.review.etime<scoreStime.GetInt64() && contest.score.stime<scoreEtime.GetInt64())
                                            {
                                                contest.score.etime=scoreEtime.GetInt64();
                                            }
                                            else
                                            {
                                                return Ok(new { code = 5, msg = "作品公布时间不能早于作品评审结束时间！" });
                                            }
                                        }
                                        else
                                        {
                                            return Ok(new { code = 6, 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 = 1, 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;
                                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.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())
                                        {
                                            foreach (var item in result.list)
                                            {
                                                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 IdNameCode { id= item.id, name=item.name, nickname=item.tmdname, picture=item.picture }); });
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                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();
                            ActivityExpert activityExpert = null;
                            List<ExpertDto> expertTasks = new List<ExpertDto>();
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync($"{_activityId}", new PartitionKey("ActivityExpert"));
                            if (response.Status == 200)
                            {
                                bool change = false;
                                activityExpert = JsonDocument.Parse(response.Content).RootElement.Deserialize<ActivityExpert>();
                                var experts = activityExpert.experts.FindAll(z => string.IsNullOrWhiteSpace(z.id));
                                var tmdids = experts.Where(x => !string.IsNullOrWhiteSpace(x.tmdid)).Select(z => z.tmdid);
                                var phones = experts.Where(x => !string.IsNullOrWhiteSpace(x.mobile)).Select(z => z.mobile);
                                var emails = 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);
                                }
                                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 experts)
                                    {
                                        if (!string.IsNullOrWhiteSpace(t.tmdid))
                                        {
                                            CoreUser coreUser = coreUsers.Find(x => x.id.Equals(t.tmdid));
                                            if (coreUser != null)
                                            {
                                                change=true;
                                                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)
                                                {
                                                    change=true;
                                                    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)
                                                {
                                                    change=true;
                                                    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 (change)
                                {
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityExpert, new PartitionKey("ActivityExpert"));
                                }

                                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>();
                                }
                                List<ExpertDto> expertDtos = activityExpert.experts.Select(z => z.ToJsonString().ToObject<ExpertDto>()).ToList();
                                long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                                //进入评审环节
                                if (contest.review!= null  && now > contest.review.stime) {
                                  
                                    if (expertDtos!=null  && expertDtos.Count()>0)
                                    {
                                        var hasIds = expertDtos.Where(x => !string.IsNullOrWhiteSpace(x.id));
                                        if (hasIds!=null  && hasIds.Count()>0)
                                        {
                                            string taskSql = $"select value c from c where c.id in ({string.Join(",", hasIds.Select(z => $"'{z.id}'"))})";
                                            var taskResults = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<ActivityExpertTask>(taskSql, $"ActivityExpertTask-{_activityId}");

                                            foreach (var item in taskResults.list) {
                                                var dto = expertDtos.Find(z => !string.IsNullOrWhiteSpace(z.id)  &&  z.id.Equals(item.id));
                                                if (dto!=null  )
                                                {
                                                    dto.taskCount =item.contestTasks.Count();
                                                    dto.teacherCount=item.contestTasks.SelectMany(z => z.members).Count();
                                                    dto.completeCount=item.contestTasks.Where(z => z.status==1).Count();
                                                    dto.uploads=  item.contestTasks.Select(z => new ContestUploadData { name = z.name, id=z.uploadId, code=string.Join(",", z.uploadTypes), count=z.count,status= z.status,score=z.score, detailScore=z.detailScore }).ToList();
                                                }
                                            }
                                        }
                                    }
                                }
                                expertTasks.AddRange(expertDtos);
                            }
                            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 (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);
                            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;
                                        }
                                        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.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;
                                    }
                                    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.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 ="作品不存在！"});
                            }
                          
                        }
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{ex.Message}\n{ex.StackTrace}", 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)
        {
            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);
            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 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 (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";
                    }
                    z.sas= _azureStorage.GetBlobContainerSAS(cnt, BlobContainerSasPermissions.Read).sas;
                });
                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;
                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;
                return Ok(new { code = 200, activity, contest, reviewRule, training, research });
            }
            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";
                    }
                    website.sas= _azureStorage.GetBlobContainerSAS(cnt, BlobContainerSasPermissions.Read).sas;
                    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("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}'"))}) ";
                            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}'"))})  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,
                                });
                            }
                        }
                        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)
                                {
                                }
                                else
                                {
                                    return Ok(new { code = 2, msg = "评审已关闭！" });
                                }
                            }
                            else
                            {
                                return Ok(new { code = 1, msg = "已过评审时间！" });
                            }
                        }
                        else {
                            return Ok(new { code = 3, msg = "活动不存在！" });
                        }
                        break;
                    }


            }
            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 (!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)
                                {
                                    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 (responseActivityEnrollDel.Status==201)
                                        {
                                            return Ok(new { code = 201, 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>();
                                        return Ok(new { code = 200, enroll });
                                    }
                                    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
                                        {
                                            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 (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
                                                {
                                                    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()
                                                    };
                                                    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 = 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);
                }
            }
            activities.ForEach(z =>
            {
                var (blob_uri, blob_sas) = _azureStorage.GetBlobContainerSAS(z.owner, BlobContainerSasPermissions.Read);
                z.sas=blob_sas;
            });
            return Ok(new { activities, website });
        }
    }
}