TEAMModelOS/TEAMModelBI/Controllers/OpenApi/TeacherController.cs

using Azure.Cosmos;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.Models.Dto;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.DI.AzureCosmos.Inner;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Helper.Common.StringHelper;
using System.Dynamic;
using Azure;
using TEAMModelOS.SDK.Models.Cosmos.Common;
using Azure.Messaging.ServiceBus;
using Microsoft.Extensions.Configuration;
using TEAMModelOS.Filter;
using Azure.Storage.Blobs.Models;
using HTEXLib.COMM.Helpers;
using Microsoft.AspNetCore.Authorization;
using System.Net.Http;
using System.ComponentModel.DataAnnotations;

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

        /// <summary>
        ///  获取学校教师列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-teacher-list")]
        [ApiToken(Auth = "1501", Name = "学校教师列表", RWN = "R", Limit = false)]
        public async Task<IActionResult> GetTeacherList(JsonElement json)
        {

            json.TryGetProperty("searchKey", out JsonElement _searchKey);
            List<CoreUser> coreUsers = new List<CoreUser>();
            IEnumerable<string> unexist = null;
            if (_searchKey.ValueKind.Equals(JsonValueKind.Array))
            {
                List<string> searchKey = _searchKey.ToObject<List<string>>();
                var keys = searchKey.Where(x => !string.IsNullOrWhiteSpace(x));
                var content = new StringContent(keys.ToJsonString(), Encoding.UTF8, "application/json");
                string ujson = await _coreAPIHttpService.GetUserInfos(content);
                if (!string.IsNullOrWhiteSpace(ujson))
                {
                    coreUsers = ujson.ToObject<List<CoreUser>>();
                }
                if (coreUsers.Any())
                {
                    unexist = searchKey.Except(coreUsers.Select(x => x.searchKey));
                }
                else
                {
                    return Ok(new { error = 1, msg = "没有找到对应的教师信息！" });
                }
            }


            var (id, school) = HttpContext.GetApiTokenInfo();
            List<SchoolTeacher> teachers = new List<SchoolTeacher>();
            string insql = "";
            if (coreUsers.Any())
            {
                insql = $"   c.id in  ({string.Join(",", coreUsers.Select(x => $"'{ x.id}'"))}) ";
            }
            string sql = $"select c.id,c.name ,c.picture,c.job ,c.subjectIds,c.roles from c where   {insql}";
            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<SchoolTeacher>
                (queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school}") }))
            {
                teachers.Add(item);
            }
            var teacherIds = coreUsers.Select(x => x.id).Except(teachers.Select(x => x.id));
            List<CoreUser> unjoined = coreUsers.FindAll(x => teacherIds.Contains(x.id));
            List<dynamic> tchs = new List<dynamic>();
            teachers.Select(x => new { x.id, x.name, x.picture, x.job, x.subjectIds, x.roles }).ToList().ForEach(x => {
                var coreUser = coreUsers.Find(c => c.id.Equals(x.id));
                if (coreUser != null)
                {
                    tchs.Add(new { x.id, coreUser.name, coreUser.picture, x.job, x.subjectIds, x.roles, coreUser.searchKey, school });
                }
            });
            return Ok(new
            {
                teachers = tchs,
                unjoined = unjoined.Select(x => new { x.id, x.name, x.picture, x.searchKey }),
                unexist = unexist
            });
        }
        /// <summary>
        /// 获取学校教师信息
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-teacher-info")]
        [ApiToken(Auth = "1502", Name = "学校教师信息", RWN = "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>();
                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 = 1, msg = "教师未就职该学校！" });
            }
        }




        /// <summary>
        /// 批量导入教师信息，并加入学校。可以导入学科，但需要填写学段id
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("import-school-teacher")]
        [ApiToken(Auth = "1503", Name = "批量导入教师", RWN = "R", Limit = false)]
        public async Task<IActionResult> ImportSchoolTeacher(ImportTechDto json)
        {
            //如果需要同时导入学科，则需要填写学段

            var (id, school) = HttpContext.GetApiTokenInfo();
            List<ImportTech> teachers = json.teachers;
            List<string> searchKey = teachers.Select(x => x.id).ToList();
            string ujson = null;
            var keys = searchKey.Where(x => !string.IsNullOrWhiteSpace(x));
            if (keys.Any())
            {
                var content = new StringContent(keys.ToJsonString(), Encoding.UTF8, "application/json");
                ujson = await _coreAPIHttpService.GetUserInfos(content);
            }
            List<CoreUser> coreUsers = new List<CoreUser>();
            if (!string.IsNullOrWhiteSpace(ujson))
            {
                coreUsers = ujson.ToObject<List<CoreUser>>();
            }
            IEnumerable<string> unexist = new List<string>();
            if (coreUsers.Any())
            {
                unexist = searchKey.Except(coreUsers.Select(x => x.id));
            }
            else
            {
                return Ok(new { error = 1, msg = "没有找到对应的教师信息！" });
            }
            var exist = coreUsers.Select(x => x.id);
            //注册了账号的教师
            teachers = teachers.Where(x => exist.Contains(x.id)).ToList();

            List<Teacher> teachersList = new List<Teacher>();
            List<SchoolTeacher> schoolTeachers = new List<SchoolTeacher>();
            string sql = $"select value(c) from c where c.id in ({string.Join(",", teachers.Select(x => $"'{x.id}'"))})";
            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher)
                .GetItemQueryIterator<Teacher>(queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey("Base") }))
            {
                teachersList.Add(item);
            }
            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
              .GetItemQueryIterator<SchoolTeacher>(queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school}") }))
            {
                schoolTeachers.Add(item);
            }
            long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
            //学校学科发生变化。
            List<SchoolTeacher> schoolTeachersAdd = new List<SchoolTeacher>();
            bool baseChange = false;
            foreach (var item in teachers)
            {
                var teacher = teachersList.Find(x => x.id.Equals(item.id));
                var coreUser = coreUsers.Find(x => x.id.Equals(item.id));
                if (teacher != null)
                {
                    var sch = teacher.schools?.Find(x => x.schoolId.Equals(school));
                    if (sch == null)
                    {
                        if (teacher.schools.IsNotEmpty())
                        {
                            teacher.schools.Add(new Teacher.TeacherSchool { schoolId = school, name = data.name, status = "invite", time = now, picture = data.picture, areaId = data.areaId });
                        }
                        else
                        {
                            teacher.defaultSchool = school;
                            teacher.size = teacher.size + 1;
                            teacher.schools = new List<Teacher.TeacherSchool> { new Teacher.TeacherSchool { schoolId = school, name = data.name, status = "invite", time = now, picture = data.picture, areaId = data.areaId } };
                        }
                    }
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReplaceItemAsync<Teacher>(teacher, teacher.id, new PartitionKey("Base"));
                }
                else
                {

                    teacher = new Teacher
                    {
                        createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                        id = coreUser.id,
                        name = coreUser.name,
                        picture = coreUser.picture,
                        defaultSchool = school,
                        size = 2,
                        code = "Base",
                        pk = "Base",
                        schools = new List<Teacher.TeacherSchool> { new Teacher.TeacherSchool { schoolId = school, name = data.name, status = "invite", time = now, picture = data.picture, areaId = data.areaId } }
                    };
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).CreateItemAsync(teacher, new PartitionKey("Base"));
                }
                var schoolTeacher = schoolTeachers.Find(x => x.id.Equals(item.id));
                //处理导入的学科
                List<string> subjectIds = new List<string>();
                if (item.subjects.IsNotEmpty() && !string.IsNullOrWhiteSpace(item.periodId))
                {
                    item.subjects.ForEach(s => {
                        //同名学科
                        var subject = data.period.Find(x => x.id.Equals(item.periodId))?.subjects?.Find(x => x.id.Equals(s.id));
                        if (subject == null)
                        {
                            subject = data.period.Find(x => x.id.Equals(item.periodId))?.subjects?.Find(x => x.name.Equals(s.name));
                        }
                        else
                        {
                            subjectIds.Add(subject.id);
                        }
                        if (subject == null)
                        {
                            var period = data.period.Find(x => x.id.Equals(item.periodId));
                            if (period != null)
                            {
                                period.subjects.Add(new Subject { id = s.id, name = s.name, type = 2 });
                                subjectIds.Add(s.id);
                                baseChange = true;
                            }
                        }
                    });
                }
                if (schoolTeacher == null)
                {
                    schoolTeacher = new SchoolTeacher
                    {
                        id = item.id,
                        name = coreUser.name,
                        picture = coreUser.picture,
                        job = item.job,
                        subjectIds = subjectIds,
                        roles = new List<string> { "teacher" },
                        permissions = new List<string> { "content-read", "exercise-read", "knowledge-read", "syllabus-read" },
                        status = "invite",
                        code = $"Teacher-{school}",
                        pk = "Teacher",
                        createTime = now,
                    };
                    schoolTeachersAdd.Add(schoolTeacher);
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).CreateItemAsync(schoolTeacher, new PartitionKey(schoolTeacher.code));
                }
                else
                {
                    if (subjectIds.IsNotEmpty())
                    {
                        subjectIds.ForEach(x => {
                            if (!schoolTeacher.subjectIds.Contains(x))
                            {
                                schoolTeacher.subjectIds.Add(x);
                            }
                        });
                    }
                    schoolTeacher.job = string.IsNullOrWhiteSpace(item.job) ? schoolTeacher.job : item.job;
                    schoolTeachersAdd.Add(schoolTeacher);
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync(schoolTeacher, schoolTeacher.id, new PartitionKey(schoolTeacher.code));
                }
            }
            if (baseChange)
            {
                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync(data, data.id, new PartitionKey("Base"));
            }
            return Ok(new { teachers = schoolTeachersAdd.Select(x => new { x.id, x.name, x.picture, x.job, x.subjectIds, x.roles, school }) });
        }
    }

    public class ImportTechDto
    {
        public List<ImportTech> teachers { get; set; } = new List<ImportTech>();
    }
    public class ImportTech
    {
        [Required(ErrorMessage = "教师id必须设置")]
        public string id { get; set; }
        public List<ImportTechSubject> subjects { get; set; }
        [RegularExpression(@"[0-9a-zA-Z]{8}(-[0-9a-zA-Z]{4}){3}-[0-9a-zA-Z]{12}", ErrorMessage = "学段的uuid格式错误！")]
        public string periodId { get; set; }
        public string job { get; set; }
    }
    public class ImportTechSubject
    {
        [RegularExpression(@"[0-9a-zA-Z]{8}(-[0-9a-zA-Z]{4}){3}-[0-9a-zA-Z]{12}", ErrorMessage = "科目的uuid格式错误！")]
        public string id { get; set; }
        [Required(ErrorMessage = "科目名称 必须设置")]
        public string name { get; set; }
    }

}