TEAMModelOS/TEAMModelAPI/Controllers/School/SchoolController.cs

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using System.Text.Json;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Extension;
using Azure.Cosmos;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;
using System.IO;
using System.Dynamic;
using System.Net.Http;
using System.Net;
using Newtonsoft.Json;
using System.Linq;
using StackExchange.Redis;
using static TEAMModelOS.SDK.Models.Teacher;
using Microsoft.Extensions.Configuration;
using TEAMModelOS.Filter;
using Microsoft.AspNetCore.Authorization;
using HTEXLib.COMM.Helpers;
using TEAMModelOS.SDK.Models.Service;

namespace TEAMModelAPI.Controllers
{
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ApiController]
    [Route("school")]
    public class SchoolController : ControllerBase
    {
        public AzureCosmosFactory _azureCosmos;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly IConfiguration _configuration;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        public SchoolController(CoreAPIHttpService coreAPIHttpService, AzureCosmosFactory azureCosmos, AzureStorageFactory azureStorage, AzureRedisFactory azureRedis, DingDing dingDing, IOptionsSnapshot<Option> option, IConfiguration configuration)
        {
            _azureCosmos = azureCosmos;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
            _dingDing = dingDing;
            _option = option?.Value;
            _configuration = configuration;
            _coreAPIHttpService=coreAPIHttpService;
        }

        /// <summary>
        ///  学校基础信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpGet("get-school-info")]
        [ApiToken(Auth = "101",Name = "学校基础信息", RW = "R", Limit =false)]
        public async Task<IActionResult> GetSchoolInfo()
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
            List<dynamic> period = new List<dynamic>();
            data.period.ForEach(x => { period.Add(new { x.subjects ,x.grades,x.name,x.id,x.campusId,x.semesters}); });
            return Ok(new { 
                id = data.id, name = data.name, data.areaId, type = data.type, 
                data.region, data.province, data.city, data.dist,
                campuses=data.campuses,
                period
            });
        }

        /// <summary>
        ///  获取学校教师列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpGet("get-teacher-list")]
        [ApiToken(Auth = "102", Name = "学校教师列表", RW = "R", Limit = false)]
        public async Task<IActionResult> GetTeacherList()
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            List<dynamic> teachers= new List<dynamic>();
            string sql = $"select c.id,c.name ,c.picture,c.job ,c.subjectIds,c.roles from c where c.status='join' ";
            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<dynamic>
                (queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school}") })) {
                teachers.Add(item);
            }
            return Ok(new
            {
                teachers
            });
        }
        /// <summary>
        /// 获取学校教师信息
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-teacher-info")]
        [ApiToken(Auth = "103", Name = "学校教师信息", RW = "R", Limit = false)]
        public async Task<IActionResult> GetTeacherInfo(JsonElement json )
        {
            json.TryGetProperty("tmdid", out JsonElement _tmdid);
            var (id, school) = HttpContext.GetApiTokenInfo();
            Azure.Response responseSchoolTch =await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School")
                .ReadItemStreamAsync($"{_tmdid}", new PartitionKey($"Teacher-{school}"));
            Azure.Response responseTch = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher")
                 .ReadItemStreamAsync($"{_tmdid}", new PartitionKey($"Base"));
            Teacher teacher = null;
            if (responseTch.Status == 200)
            {
                teacher = JsonDocument.Parse(responseTch.Content).RootElement.Deserialize<Teacher>();
            }
            else
            {
                return Ok(new { error = 3, msg = "账号未创建！" });
            }
            if (responseSchoolTch.Status == 200 && teacher!= null )
            {
                SchoolTeacher schoolTeacher= JsonDocument.Parse(responseSchoolTch.Content).RootElement.Deserialize<SchoolTeacher>();
                if (schoolTeacher.status.Equals("join"))
                {
                    return Ok(new {teacher.id,teacher.name,teacher.picture,schoolTeacher.job,schoolTeacher.status,schoolTeacher.roles,schoolTeacher.subjectIds, school=teacher.schools?.Find(x=>x.schoolId.Equals(school)) } );
                }
                else
                {
                    return Ok(new { error = 2, msg = "教师未加入学校！" });
                }

            }
            else {
                return Ok(new { error = 1, msg = "教师未就职该学校！" });
            }
        }

        /*
            "periodId":"学段（选填）"
         */
        /// <summary>
        ///  获取学校的行政班，教学班，教研组，研修名单
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-group-list")]
        [ApiToken(Auth = "104", Name = "学校教师列表", RW = "R", Limit = false)]
        public async Task<IActionResult> GetGroupList(JsonElement json)
        {
            var client = _azureCosmos.GetCosmosClient();
            var (id, school) = HttpContext.GetApiTokenInfo();
            json.TryGetProperty("periodId", out JsonElement periodId);
            List<GroupListGrp> groupLists = new List<GroupListGrp>();
            //包含，学校的行政班，教学班
            json.TryGetProperty("type", out JsonElement _type);
            List<string> types = null;
            if (_type.ValueKind.Equals(JsonValueKind.Array))
            {
                types = _type.ToObject<List<string>>();
            }
            else if (_type.ValueKind.Equals(JsonValueKind.String))
            {
                types = new List<string> { $"{types}" };
            }
            if (types.IsEmpty() || types.Contains("class"))
            {
                StringBuilder classsql = new StringBuilder($"SELECT c.id,c.name,c.periodId ,c.year  FROM c ");
                if (!string.IsNullOrEmpty($"{periodId}"))
                {
                    classsql.Append($" where  c.periodId='{periodId}' ");
                }
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<ClassInfo>(queryText: classsql.ToString(),
                    requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Class-{school}") }))
                {
                    HashSet<string> groupNames = new HashSet<string>();
                    string gpsql = $"SELECT distinct c.groupId,c.groupName FROM c where  c.classId='{item.id}'and c.groupName <>null";
                    await foreach (var gp in client.GetContainer(Constant.TEAMModelOS, "Student").GetItemQueryIterator<Student>(queryText: gpsql,
                        requestOptions: new QueryRequestOptions() { PartitionKey = new Azure.Cosmos.PartitionKey($"Base-{school}") }))
                    {
                        groupNames.Add(gp.groupName);
                    }
                    ///行政班（学生搜寻classId动态返回）class
                    GroupListGrp group = new GroupListGrp
                    {
                        id = item.id,
                        code = $"GroupList-{school}",
                        name = item.name,
                        periodId = item.periodId,
                        scope = "school",
                        school = $"{school}",
                        type = "class",
                        year = item.year,
                        groupName = groupNames
                    };
                    groupLists.Add(group);
                }
            }
            if (types.IsEmpty() || types.Contains("teach"))
            {
                //教学班
                StringBuilder teachsql = new StringBuilder($" SELECT distinct value(c) FROM c  where c.type='teach'");
                if (!string.IsNullOrEmpty($"{periodId}"))
                {
                    teachsql.Append($" and c.periodId='{periodId}'");
                }
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                    GetItemQueryIterator<GroupList>(queryText: teachsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                {
                    HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                    groupLists.Add(new GroupListGrp(item, groupName));
                }
            }
            if (types.IsEmpty() || types.Contains("research"))
            {
                //教研组
                StringBuilder researchsql = new StringBuilder($"SELECT distinct value(c) FROM c   where c.type='research'");
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                    GetItemQueryIterator<GroupList>(queryText: researchsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                {
                    HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                    groupLists.Add(new GroupListGrp(item, groupName));
                }
            }

            if (types.IsEmpty() || types.Contains("yxtrain"))
            {
                //研修名单
                StringBuilder yxtrainsql = new StringBuilder($"SELECT distinct value(c) FROM c    where c.type='yxtrain'");
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                    GetItemQueryIterator<GroupList>(queryText: yxtrainsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                {
                    HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                    groupLists.Add(new GroupListGrp(item, groupName));
                }
            }
            return Ok(new
            {
                groupLists=groupLists.Select(x=>new { x.id,x.type,x.name,x.periodId,x.school,x.scope,x.year})
            });
        }

        [ProducesDefaultResponseType]
        [HttpPost("get-group-members")]
        [ApiToken(Auth = "105", Name = "获取名单详细信息和成员信息", RW = "R", Limit = false)]
        public async Task<IActionResult> GetGroupMembers(JsonElement json)
        {
            var client = _azureCosmos.GetCosmosClient();
            if (!json.TryGetProperty("ids", out JsonElement ids)) return BadRequest();
            var (id, school) = HttpContext.GetApiTokenInfo();
            List<string> listids = ids.ToObject<List<string>>();
            (List<RMember> members, List<RGroupList> groups) = await GroupListService.GetStutmdidListids(_coreAPIHttpService, client, _dingDing, listids, $"{school}");
            return Ok(new { groups = groups.Select(x => new { x.name, x.no, x.periodId, x.school, x.type, x.year, x.tcount, x.scount, x.leader, x.members, x.id }), members });
        }
       
        [ProducesDefaultResponseType]
        [HttpPost("get-course-list")]
        [ApiToken(Auth = "106", Name = "获取课程列表信息",RW ="R", Limit = false)]
        public async Task<IActionResult> GetCourseList(JsonElement json) {
            var client = _azureCosmos.GetCosmosClient();
            var (id, school) = HttpContext.GetApiTokenInfo();
            json.TryGetProperty("periodId", out JsonElement periodId);
            json.TryGetProperty("subjectId", out JsonElement subjectId);
            StringBuilder sql = new StringBuilder($"SELECT c.id,c.name,c.subject,c.period,c.scope,c.no,c.school FROM c where 1=1 ");
            if (!string.IsNullOrWhiteSpace($"{periodId}")) {
                sql.Append($" and c.period.id='{periodId}'");
            }
            if (!string.IsNullOrWhiteSpace($"{subjectId}"))
            {
                sql.Append($" and c.subject.id='{subjectId}'");
            }
            List<dynamic> courses = new List<dynamic>();
            await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                    GetItemQueryIterator<dynamic>(queryText: sql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Course-{school}") }))
            {
                courses.Add(item);
            }
            return Ok(new { courses });
        }
       
        [ProducesDefaultResponseType]
        [HttpPost("get-course-info")]
        [ApiToken(Auth = "107", Name = "课程详细信息", RW = "R", Limit = false)]
        public async Task<IActionResult> GetCourseInfo(JsonElement json)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            json.TryGetProperty("courseId", out JsonElement courseId);
            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School")
               .ReadItemStreamAsync($"{courseId}", new PartitionKey($"Course-{school}"));
            if (response.Status == 200)
            {
                JsonDocument document= JsonDocument.Parse(response.Content);
                Course course= document.RootElement.Deserialize<Course>();
                return Ok(new { course.name,course.id, course.subject, course .period, course .scope, course.school, course .no, course .desc, course.schedule});
            }
            else {
                return Ok(new { error=1,msg="课程不存在！"});
            }
        }
        /// <summary>
        /// 获取物理教室列表
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-room-list")]
        [ApiToken(Auth = "108", Name = "获取物理教室列表", RW = "R", Limit = false)]
        public async Task<IActionResult> GetRoomList(JsonElement json)
        {
            var client = _azureCosmos.GetCosmosClient();
            var (id, school) = HttpContext.GetApiTokenInfo();
            StringBuilder sql = new StringBuilder($"select value(c) from c where 1=1 ");
            json.TryGetProperty("openType", out JsonElement openType);
            if (!string.IsNullOrWhiteSpace($"{openType}"))
            {
                sql.Append($" and c.openType='{openType}'");
            }
            
            List<Room> rooms = new List<Room>();
            await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<Room>(queryText: sql.ToString(),
            requestOptions: new QueryRequestOptions() { PartitionKey = new Azure.Cosmos.PartitionKey($"Room-{school}") }))
            {
                rooms.Add(item);
            }
            return Ok(new { rooms =rooms.Select(x=>new {x.id,x.name,x.x,x.y, x.openType,x.style,x.area,x.address,school=school})  });
        }
        /// <summary>
        /// 获取物理教室详细信息
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-room-info")]
        [ApiToken(Auth = "109", Name = "获取物理教室详细信息", RW = "R", Limit = false)]
        public async Task<IActionResult> GetRoomInfo(JsonElement json)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            if (!json.TryGetProperty("roomId", out JsonElement roomId)) return BadRequest();
            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School")
              .ReadItemStreamAsync($"{roomId}", new PartitionKey($"Room-{school}"));
            if (response.Status == 200)
            {
                JsonDocument document = JsonDocument.Parse(response.Content);
                Room room = document.RootElement.Deserialize<Room>();
                return Ok(new { room.id, room.name, room.x, room.y, room.openType, room.style, room.area,room.address, school = school });
            }
            else
            {
                return Ok(new { error = 1, msg = "教室不存在！" });
            }
        }

        /// <summary>
        ///  获取试卷和评测的条件信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-paper-exam-condition")]
        [ApiToken(Auth = "110", Name = "试卷和评测的条件信息", RW = "R", Limit = false)]
        public async Task<IActionResult> GetPaperExamCondition(JsonElement json)
        {
            json.TryGetProperty("periodId", out JsonElement _periodId);
            var (id, school) = HttpContext.GetApiTokenInfo();
            School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
            var exmaType = new { type = new List<string> { "regular", "simulation", "normal" } };//regula ,正规考,  simulation 模拟靠考，normal 普通考
            var exmaMode = new { type = new List<string> { "0", "1", "2" } };//0 线上评测,  1 课中评测 ，2 阅卷评测
            var period = data.period.Find(x => x.id.Equals($"{_periodId}"));
            if (period != null)
            {
                return Ok(new { period.subjects, period.analysis, period.grades, exmaType, exmaMode });
            }
            else
            {
                return Ok(new { error = 1, msg = "学段不存在！" });
            }

        }
    }
}