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.Text.RegularExpressions;
using Microsoft.AspNetCore.Authorization;
using OpenXmlPowerTools;
using System.IdentityModel.Tokens.Jwt;
using Microsoft.AspNetCore.Routing;
using Pipelines.Sockets.Unofficial.Arenas;
using Grpc.Core;
using static TEAMModelOS.SDK.CoreAPIHttpService;
using Top.Api;
using System.Net;
using TEAMModelOS.SDK.Models.Service;
using DocumentFormat.OpenXml.Office2010.Excel;
using TEAMModelOS.Services;
using OfficeOpenXml.FormulaParsing.LexicalAnalysis;
using Azure.Storage.Sas;
using DocumentFormat.OpenXml.Bibliography;
using System.Runtime.Intrinsics.X86;
using Microsoft.IdentityModel.Tokens;
using TEAMModelOS.SDK.Models.Dtos;
using System.Net.Http;

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; }
        public ActivityController(AzureRedisFactory azureRedis, AzureCosmosFactory azureCosmos, DingDing dingDing, IOptionsSnapshot<Option> option, CoreAPIHttpService coreAPIHttpService, AzureServiceBusFactory serviceBus, AzureStorageFactory azureStorage, IConfiguration configuration, HttpTrigger httpTrigger, IPSearcher searcher)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _option = option?.Value;
            _serviceBus = serviceBus;
            _configuration = configuration;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
            _coreAPIHttpService = coreAPIHttpService;
            _httpTrigger=httpTrigger;
            _searcher=searcher;
        }

        /// <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 }) });
                        }
                        break;
                    }
            }
            return Ok(new { code = 400 });
        }

        /// <summary>
        /// 管理
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "teacher,admin,area")]
        [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("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 reviewRule = await ActivityService.UpsertReviewRule(ruleTree, activity, _azureCosmos);
                                                            contest.review.ruleId = reviewRule.id;
                                                            contest.review.ruleName = reviewRule.name;
                                                        }
                                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).UpsertItemAsync(contest, new PartitionKey(contest.code));
                                                    }
                                                    else {
                                                        return Ok(validResult);
                                                    }
                                                }
                                                break;
                                            }
                                        //培训
                                        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"));
                                    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"));
                                        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();
                            string yearSql = $" and c.year={DateTimeOffset.Now.Year}";

                            if (request.TryGetProperty("year", out JsonElement _year)) {
                                yearSql = $" and c.year={_year}";
                            }
                            string sql = $"select value c from c where c.owner='{_areaId}' {yearSql}  ";
                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sql, "Activity");
                            result.list.ForEach(z => {
                                var (blob_uri, blob_sas) = _azureStorage.GetBlobContainerSAS(z.owner, BlobContainerSasPermissions.Read | BlobContainerSasPermissions.List);
                                z.sas=blob_sas;
                            });
                            return Ok(new { activities = result.list.OrderByDescending(z => z.stime) });
                        }
                    //校级活动列表
                    case bool when $"{grant_type}".Equals("list-school", StringComparison.OrdinalIgnoreCase):
                        {
                            if (!string.IsNullOrWhiteSpace(school)) {
                                School schoolbase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                                List<Activity> activities = new List<Activity>();
                                string yearSql = $" and c.year={DateTimeOffset.Now.Year}";

                                if (request.TryGetProperty("year", out JsonElement _year))
                                {
                                    yearSql = $" and c.year={_year}";
                                }
                                //获取开放的
                                {

                                    //完全开放 所有的学校
                                    string sqlOpen = $"select value c from c where c.scope='public' {yearSql}  and (c.publish=1 or c.publish=2 )  and( ARRAY_LENGTH(c.invitedSchools)=0 or IS_DEFINED(c.invitedSchools) = false  ) ";
                                    var resultOpen = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlOpen, "Activity");
                                    activities.AddRange(resultOpen.list);
                                    //部分学校
                                    string sqlSchool = $"select value c from c  join s in c.invitedSchools  where c.scope='public' {yearSql}  and (c.publish=1 or c.publish=2 )  and s.id='{school}' ";
                                    var resultSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlSchool, "Activity");
                                    resultSchool.list.ForEach(z => {
                                        var confirmedSchool = z.confirmedSchools.Find(z => z.id.Equals(school));
                                        if (confirmedSchool==null)
                                        {
                                            z.confirmedSchools.Add(new ActivityConfirmedSchool
                                            {
                                                id=schoolbase.id,
                                                name=schoolbase.name,
                                                picture=schoolbase.picture,
                                                status=0
                                            });
                                        }
                                    });
                                    activities.AddRange(resultSchool.list);
                                }
                                //获取区级下放的
                                {

                                    if (!string.IsNullOrWhiteSpace(schoolbase.areaId)) {
                                        //区级所有学校
                                        string sqlOpen = $"select value c from c where c.scope='area'{yearSql}   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) ";
                                        var resultOpen = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlOpen, "Activity");
                                        resultOpen.list.ForEach(z => {
                                            var confirmedSchool = z.confirmedSchools.Find(z => z.id.Equals(school));
                                            if (confirmedSchool==null)
                                            {
                                                z.confirmedSchools.Add(new ActivityConfirmedSchool
                                                {
                                                    id=schoolbase.id,
                                                    name=schoolbase.name,
                                                    picture=schoolbase.picture,
                                                    status=0
                                                });
                                            }
                                        });
                                        activities.AddRange(resultOpen.list);
                                        //区级部分学校
                                        string sqlSchool = $"select value c from c  join s in c.invitedSchools  where c.scope='area'{yearSql}  and (c.publish=1 or c.publish=2 )  and  c.owner='{schoolbase.areaId}' and s.id='{school}' ";
                                        var resultSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlSchool, "Activity");
                                        resultSchool.list.ForEach(z => {
                                            var confirmedSchool = z.confirmedSchools.Find(z => z.id.Equals(school));
                                            if (confirmedSchool==null)
                                            {
                                                z.confirmedSchools.Add(new ActivityConfirmedSchool
                                                {
                                                    id=schoolbase.id,
                                                    name=schoolbase.name,
                                                    picture=schoolbase.picture,
                                                    status=0
                                                });
                                            }
                                        });
                                        activities.AddRange(resultSchool.list);
                                    }
                                }
                                //获取学校自己的
                                {
                                    string sqlSchool = $"select value c from c where c.scope='school'{yearSql} and  c.owner='{school}'  ";
                                    var resultSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlSchool, "Activity");
                                    activities.AddRange(resultSchool.list);
                                }
                                activities.ForEach(z => {
                                    var (blob_uri, blob_sas) = _azureStorage.GetBlobContainerSAS(z.owner, BlobContainerSasPermissions.Read | BlobContainerSasPermissions.List);
                                    z.sas=blob_sas;
                                });
                                return Ok(new { activities = activities.OrderByDescending(z => z.stime) });
                            }
                            break;

                        }
                    //教师活动列表
                    case bool when $"{grant_type}".Equals("list-teacher", StringComparison.OrdinalIgnoreCase):
                        {
                            List<Activity> activities = new List<Activity>();
                            HashSet<string> inviteActivityIds = new HashSet<string>();
                            string yearSql = $" and c.year={DateTimeOffset.Now.Year}";
                            if (request.TryGetProperty("year", out JsonElement _year))
                            {
                                yearSql = $" and c.year={_year}";
                            }
                            //先获取邀请制的
                            string sqlInvite = $"select value c from c join t in c.inviteTeachers where   t.id='{tmdid}'";
                            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<ActivityTeacher>(sqlInvite, "ActivityTeacher");
                            inviteActivityIds= result.list.Select(z => z.id).ToHashSet();
                            if (inviteActivityIds.Count>0) {
                                string sqlActivity = $"select value c from c  where c.id in ({string.Join(",", inviteActivityIds.Select(z => $"'{z}'"))}) {yearSql} ";
                                var resultActivity = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlInvite, "ActivityTeacher");
                                if (resultActivity.list.IsNotEmpty()) {
                                    activities.AddRange(resultActivity.list);
                                }
                            }
                            Teacher teacher = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemAsync<Teacher>(tmdid, new PartitionKey("Base"));
                            string schoolOwnerIn = string.Empty;
                            string schoolIdIn = string.Empty;
                            if (teacher.schools.IsNotEmpty()) {
                                schoolIdIn = $"and i.id in ({string.Join(",", teacher.schools.Select(z => $"'{z.schoolId}'"))})";
                                schoolOwnerIn= $"and c.owner in ({string.Join(",", teacher.schools.Select(z => $"'{z.schoolId}'"))})";
                            }
                            //获取开放的
                            {
                                //完全开放 所有的学校
                                string sqlOpen = $"select value c from c where c.scope='public' and (c.publish=1 or c.publish=2 )  and( ARRAY_LENGTH(c.invitedSchools)=0 or IS_DEFINED(c.invitedSchools) = false  )  {yearSql} ";
                                var resultOpen = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlOpen, "Activity");
                                activities.AddRange(resultOpen.list);

                                if (!string.IsNullOrWhiteSpace(schoolIdIn))
                                {   //部分学校
                                    string sqlSchool = $"select value c from c join i in c.confirmedSchools  where c.scope='public' and c.joinMode='enroll'  and (c.publish=1 or c.publish=2 )  and i.status=1 {yearSql}  {schoolIdIn}  ";
                                    var resultSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlSchool, "Activity");
                                    activities.AddRange(resultSchool.list);
                                }

                            }
                            string areaOwnerIn = string.Empty;
                            var hasAreaSchools = teacher.schools.FindAll(z => !string.IsNullOrWhiteSpace(z.areaId));
                            if (hasAreaSchools.IsNotEmpty())
                            {
                                areaOwnerIn = $"and c.owner in ({string.Join(",", hasAreaSchools.Select(z => $"'{z.areaId}'"))})";
                                schoolIdIn = $"and i.id in ({string.Join(",", hasAreaSchools.Select(z => $"'{z.schoolId}'"))})";
                            }
                            //获取所有区级的
                            if (!string.IsNullOrWhiteSpace(areaOwnerIn) && !string.IsNullOrEmpty(schoolIdIn)) {

                                string sqlOpen = $"select value c from c join i  in c.confirmedSchools where c.scope='area'  and c.joinMode='enroll' and (c.publish=1 or c.publish=2 ) and i.status=1 {yearSql}  {areaOwnerIn}   {schoolIdIn} ";
                                var resultOpen = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlOpen, "Activity");
                                activities.AddRange(resultOpen.list);
                            }

                            //获取所有学校的
                            if (!string.IsNullOrWhiteSpace(schoolOwnerIn))
                            {
                                string sqlSchool = $"select value c from c where c.scope='school'  and c.joinMode='enroll'  and (c.publish=1 or c.publish=2 ) {yearSql}  {schoolOwnerIn}  ";
                                var resultSchool = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Common).GetList<Activity>(sqlSchool, "Activity");
                                activities.AddRange(resultSchool.list);
                            }

                            activities.ForEach(z => {
                                var (blob_uri, blob_sas) = _azureStorage.GetBlobContainerSAS(z.owner, BlobContainerSasPermissions.Read | BlobContainerSasPermissions.List);
                                z.sas=blob_sas;
                            });
                            return Ok(new { activities = activities.OrderByDescending(z => z.stime) });
                        }
                    //读取优课评选模块及评审规则
                    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
                                        };
                                    }
                                }
                            }
                            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
                                };
                                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"));
                                var reviewRuleDB = await ActivityService.UpsertReviewRule(ruleTree, activity, _azureCosmos);
                                var tree = ActivityService.ListToTree(reviewRuleDB.configs);
                                var reviewRule = new ReviewRuleTree
                                {
                                    id=reviewRuleDB.id,
                                    name= reviewRuleDB.name,
                                    owner= reviewRuleDB.owner,
                                    sourceName= reviewRuleDB.sourceName,
                                    trees=tree,
                                    desc=reviewRuleDB.desc
                                };
                                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("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) {
                                            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"));
                                                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 = "活动发布状态错误!" });
                                    }
                                }
                            }
                            break;
                        }
                    //发布或取消发布活动
                    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(activity.id, new PartitionKey("ActivityTeacher"));
                                        if (activityTeacherResponse.Status==200)
                                        {
                                            activityTeacher = JsonDocument.Parse(activityTeacherResponse.Content).RootElement.ToObject<ActivityTeacher>();
                                        }
                                        if (activityTeacher==null) {
                                            activityTeacher= new ActivityTeacher() { id= activity.id, code="ActivityTeacher", 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));
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(activityTeacher, new PartitionKey("ActivityTeacher"));
                                        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("invited-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>();
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(_activityId.GetString(), new PartitionKey("ActivityTeacher"));
                            if (response.Status==200) {
                                ActivityTeacher activityTeacher = JsonDocument.Parse(response.Content).RootElement.ToObject<ActivityTeacher>();
                                if (isAll==1)
                                {
                                    if (activityTeacher.inviteTeachers.IsNotEmpty()) {
                                        inviteTeachers.AddRange(activityTeacher.inviteTeachers);
                                    }
                                }
                                else
                                {
                                    if (!string.IsNullOrWhiteSpace(school))
                                    {
                                        var teachers = activityTeacher.inviteTeachers.FindAll(z => !string.IsNullOrWhiteSpace(z.school)  && z.school.Equals(school));
                                        if (teachers.IsNotEmpty()) {
                                            inviteTeachers.AddRange(teachers);
                                        }
                                    }
                                }
                            }
                            return Ok(new { 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.Normal).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.Normal).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.Normal).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.Normal).UpsertItemAsync(activityExpert, new PartitionKey("ActivityExpert"));
                                }
                                if (remove_experts.IsNotEmpty()) {
                                    if (activityExpert == null)
                                    {
                                        Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).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.Normal).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;
                            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Normal).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.Normal).UpsertItemAsync(activityExpert, new PartitionKey("ActivityExpert"));
                                }
                            }
                            return Ok(new { activityExpert, code = 200 });
                        }
                }
            } 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.Normal).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);
            return Ok(new {  code =200,token =serializeToken, schools= teacherInfo.teacher.schools.Where(z=>z.status.Equals("join"))});
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [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<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)
            {
                List<ActivityWebsite> websites = new List<ActivityWebsite>();
                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<ActivityWebsite>(sqlAll, "ActivityWebsite");
                    websites=resultAll.list;
                }
                return Ok(new { code = 200, website ,websites });
            }
            else {
                return Ok(new { code = 2, msg = "未匹配分站" }) ;
            }
          
        }
        /// <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<Activity> activities = new List<Activity>();
            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<Activity>(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<Activity>(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<Activity>(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<Activity>(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<Activity>(sqlOpen, "Activity");
                    activities.AddRange(resultOpen.list);
                }
            }
             
            return Ok(new { activities, website });
        }
    }
}