TEAMModelOS/TEAMModelOS/Controllers/School/ClassRoomController.cs

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Helper.Common.ValidateHelper;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using System.Linq;
using System.Text.Json;
using TEAMModelOS.Models.SchoolInfo;
using TEAMModelOS.Models.StudentInfo;
using System.IdentityModel.Tokens.Jwt;
using TEAMModelOS.SDK.Extension;
using Azure.Cosmos;
using Microsoft.AspNetCore.Http;
using TEAMModelOS.SDK.DI.AzureCosmos.Inner;
using TEAMModelOS.Models.TeacherInfo;

namespace TEAMModelOS.Controllers
{
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    //[Authorize(Roles = "IES5")]
    [Route("school/classroom")]
    [ApiController]
    public  class ClassroomController : ControllerBase
    {
        public readonly AzureCosmosFactory _azureCosmos;
        public ClassroomController(AzureCosmosFactory azureCosmos) {
            _azureCosmos = azureCosmos;
        }
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "Teacher")]
        [HttpPost("upsert")]
        public async ValueTask<IActionResult> Upsert(JsonElement requert)
        {
            //ResponseBuilder builder = ResponseBuilder.custom();
            //List<Student> students = null;
            Classroom classroom;
            if (!requert.TryGetProperty("classroom", out JsonElement room)) return BadRequest();
            if (!requert.TryGetProperty("option", out JsonElement option)) return BadRequest();
            if (!requert.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
            classroom = room.ToObject<Classroom>();
            var client = _azureCosmos.GetCosmosClient();
            classroom.ttl = -1;
            classroom.pk = typeof(Classroom).Name;
            classroom.code = "Class-" + school_code.ToString();
            //students = await _azureCosmos.FindByDict<Student>(new Dictionary<string, object>() { { "classroomCode", classroom.id } });
            if (option.ToString().Equals("insert"))
            {
                if (classroom.scope.Equals("private"))
                {
                    var response = await client.GetContainer("TEAMModelOS", "Teacher").ReadItemStreamAsync(classroom.id, new PartitionKey($"Class-{school_code}"));
                    if (response.Status == 200)
                    {
                        //classroom = await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "School").UpsertItemAsync(requert, new PartitionKey($"Classroom-{classroom.code}"));
                        return Ok(new { error = ResponseCode.DATA_EXIST, V = "班级编码已经存在！" });
                    }
                    else
                    {
                        //string code = classroom.code;
                        //classroom.code = "Class-" + school_code;
                        classroom = await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "Teacher").CreateItemAsync(classroom, new PartitionKey($"Class-{school_code}"));

                    }
                }
                else {
                    var response = await client.GetContainer("TEAMModelOS", "School").ReadItemStreamAsync(classroom.id, new PartitionKey($"Class-{school_code}"));
                    if (response.Status == 200)
                    {
                        //classroom = await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "School").UpsertItemAsync(requert, new PartitionKey($"Classroom-{classroom.code}"));
                        return Ok(new { error = ResponseCode.DATA_EXIST, V = "班级编码已经存在！" });
                    }
                    else
                    {
                        //string code = classroom.code;
                        //classroom.code = "Class-" + school_code;
                        classroom = await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "School").CreateItemAsync(classroom, new PartitionKey($"Class-{school_code}"));

                    }
                }                
            }
            else {
                List<StudentSimple> studentSimples = new List<StudentSimple>();
                StringBuilder sql = new StringBuilder();
                sql.Append("select A0.id,A0.name,A0.no from c join A0 in c.students ");
                Dictionary<string, object> dict = new Dictionary<string, object>();
                dict.Add("scope", classroom.scope);
                dict.Add("id", classroom.id);
                AzureCosmosQuery cosmosDbQuery = SQLHelper.GetSQL(dict, sql);
                await foreach (var item in client.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryDefinition: cosmosDbQuery.CosmosQueryDefinition, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Class-{school_code}") }))
                {
                    using var json = await JsonDocument.ParseAsync(item.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            studentSimples.Add(obj.ToObject<StudentSimple>());
                        }
                    }
                }
                classroom.students = studentSimples;
                if (classroom.scope.Equals("private"))
                {
                    classroom = await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "Teacher").ReplaceItemAsync(classroom,classroom.id, new PartitionKey($"Class-{school_code}"));
                }
                else {
                    List<TeacherCourse> course = new List<TeacherCourse>();
                    await foreach (var item in client.GetContainer("TEAMModelOS", "Teacher").GetItemQueryStreamIterator(queryText: $"select value(c) from c join A0 in c.classes where A0.id = '{classroom.id}'"))
                    {
                        using var json = await JsonDocument.ParseAsync(item.ContentStream);
                        if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                        {
                            foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                            {
                                course.Add(obj.ToObject<TeacherCourse>());
                            }
                        }
                    }
                    
                    for (int i = 0;i< course.Count;i++) {
                        bool flag = false;
                        for (int j = 0;j<course[i].classes.Count;j++) {
                            if (!course[i].classes[j].name.Equals(classroom.name)) {
                                flag = true;
                                course[i].classes[j].name = classroom.name;
                                break;                               
                            }
                        }
                        if (flag) {
                            await client.GetContainer("TEAMModelOS", "Teacher").ReplaceItemAsync(course[i], course[i].id, new PartitionKey($"{course[i].code}"));
                        }
                    }
                    //string code = classroom.code.Substring(classroom.pk.Length + 1);
                    var sresponse = await client.GetContainer("TEAMModelOS", "School").ReadItemStreamAsync(classroom.id, new PartitionKey($"CourseManagement-{school_code}"));
                    if (sresponse.Status == 200)
                    {
                        using var json = await JsonDocument.ParseAsync(sresponse.ContentStream);
                        CourseManagement classroom1 = json.ToObject<CourseManagement>();
                        if (!classroom1.name.Equals(classroom.name))
                        {
                            classroom1.name = classroom.name;
                            classroom1.teacher.name = classroom.teacher.name;
                            await client.GetContainer("TEAMModelOS", "School").ReplaceItemAsync(classroom1, classroom1.id, new PartitionKey($"{classroom1.code}"));
                        }

                    }
                    classroom = await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "School").ReplaceItemAsync(classroom, classroom.id, new PartitionKey($"Class-{school_code}"));
                }
                    
            }

            //强制关联原生班级的id
            /*List<ClassStudent> classroomStudents = await _azureCosmos.FindByDict<ClassStudent>(new Dictionary<string, object> { { "id", classroom.id } });
            if (classroomStudents.IsNotEmpty())
            {
                if (students.IsNotEmpty())
                {
                    List<ClassStudent> newClassStudents = new List<ClassStudent>();
                    students.ForEach(x =>
                    {
                        if (!classroomStudents.Select(m => m.code).Contains(x.studentId))
                        {
                            newClassStudents.Add(new ClassStudent { code = x.studentId, id = classroom.id });
                        }
                    });
                    await _azureCosmos.SaveOrUpdateAll<ClassStudent>(newClassStudents);
                }
            }*/
            return Ok(new { classroom });
        }


        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "Teacher")]
        [HttpPost("upsert-group")]
        public async ValueTask<IActionResult> UpsertGroup(JsonElement requert)
        {
            try {
                Classroom classroom = new Classroom();
                if (!requert.TryGetProperty("classroom", out JsonElement room)) return BadRequest();
                //if (!requert.TryGetProperty("code", out JsonElement code)) return BadRequest();
                classroom = room.ToObject<Classroom>();
                var client = _azureCosmos.GetCosmosClient();
                var sresponse = await client.GetContainer("TEAMModelOS", "School").ReadItemStreamAsync(classroom.id, new PartitionKey($"{classroom.code}"));
                if (sresponse.Status == 200)
                {
                    using var json = await JsonDocument.ParseAsync(sresponse.ContentStream);
                    Classroom classroom1 = json.ToObject<Classroom>();
                    classroom1.ttl = -1;                                
                    classroom1.students = classroom.students;
                    var response = await client.GetContainer("TEAMModelOS", "School").ReplaceItemAsync(classroom1, classroom1.id, new PartitionKey($"{classroom.code}"));
                }
                return Ok(new { classroom });
            } catch (Exception ex) {
                return BadRequest();
            }
            
        }

        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "Teacher")]
        [HttpPost("find")]
        public async Task<IActionResult> Find(JsonElement requert)
        {
            //ResponseBuilder builder = ResponseBuilder.custom();
            if (!requert.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
            var client = _azureCosmos.GetCosmosClient();
            List<object> classrooms = new List<object>();
            StringBuilder sql = new StringBuilder();
            sql.Append("select c.id,c.point,c.name,c.teacher,c.periodId,c.gradeId,c.sn,c.style,c.scope,c.type,c.code,c.openType,c.x,c.y,ARRAY_LENGTH(c.students) AS studCount from c ");
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = requert.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            //处理code
            if (dict.TryGetValue("school_code", out object _))
            {
                dict.Remove("school_code");
            }
            AzureCosmosQuery cosmosDbQuery = SQLHelper.GetSQL(dict, sql);
            await foreach (var item in client.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryDefinition: cosmosDbQuery.CosmosQueryDefinition, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Class-{school_code}") }))
            {
                using var json = await JsonDocument.ParseAsync(item.ContentStream);
                if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                {
                    foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                    {
                        classrooms.Add(obj.ToObject<object>());
                    }
                }
            }
            return Ok(new { classrooms });
            /*List<Classroom> sc = await _azureCosmos.FindByDict<Classroom>(request);
            return builder.Data(sc).build();*/
        }
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "Teacher")]
        [HttpPost("find-students")]
        public async Task<IActionResult> FindStudent(JsonElement requert)
        {
            //ResponseBuilder builder = ResponseBuilder.custom();
            if (!requert.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
            var client = _azureCosmos.GetCosmosClient();
            List<object> classrooms = new List<object>();
            StringBuilder sql = new StringBuilder();
            sql.Append("select c.name,c.id,c.students,c.code from c ");
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = requert.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            //处理code
            if (dict.TryGetValue("school_code", out object _))
            {
                dict.Remove("school_code");
            }
            AzureCosmosQuery cosmosDbQuery = SQLHelper.GetSQL(dict, sql);
            await foreach (var item in client.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryDefinition: cosmosDbQuery.CosmosQueryDefinition, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Class-{school_code}") }))
            {
                using var json = await JsonDocument.ParseAsync(item.ContentStream);
                if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                {
                    foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                    {
                        classrooms.Add(obj.ToObject<object>());
                    }
                }
            }
            return Ok(new { classrooms });
            /*List<Classroom> sc = await _azureCosmos.FindByDict<Classroom>(request);
            return builder.Data(sc).build();*/
        }


        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "Teacher")]
        [HttpPost("delete")]
        public async Task<IActionResult> Delete(JsonElement request)
        {
            if (!request.TryGetProperty("school_code", out JsonElement code)) return BadRequest();
            if (!request.TryGetProperty("id", out JsonElement id)) return BadRequest();
            if (!request.TryGetProperty("scope", out JsonElement scope)) return BadRequest();
            try
            {
				//string school_code = code.ToString().Substring(6);
				string school_code = code.ToString();
				Classroom classroom = new Classroom();
                var client = _azureCosmos.GetCosmosClient();
                if (scope.ToString().Equals("school"))
                {
                    List<TeacherCourse> classes = new List<TeacherCourse>();
                    classroom = await client.GetContainer("TEAMModelOS", "School").DeleteItemAsync<Classroom>(id.ToString(), new PartitionKey($"Class-{school_code}"));
                    await client.GetContainer("TEAMModelOS", "School").DeleteItemStreamAsync(id.ToString(), new PartitionKey($"CourseManagement-{school_code}"));
                    await foreach (var item in client.GetContainer("TEAMModelOS", "Teacher").GetItemQueryStreamIterator(queryText: $"select value(c) from c join A0 in c.classes where A0.id = '{id}'"))
                    {
                        using var json = await JsonDocument.ParseAsync(item.ContentStream);
                        if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                        {
                            foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                            {
                                classes.Add(obj.ToObject<TeacherCourse>());
                            }
                        }
                    }
                    for (int i = 0; i < classes.Count; i++)
                    {
                        bool flag = false;
                        for (int j = 0; j < classes[i].classes.Count; j++)
                        {
                            if (classes[i].classes[j].id.Equals(id.ToString()))
                            {
                                classes[i].classes.Remove(classes[i].classes[j]);
                                flag = true;
                            }
                        }
                        if (flag)
                        {
                            await client.GetContainer("TEAMModelOS", "Teacher").ReplaceItemAsync(classes[i], classes[i].id, new PartitionKey($"{classes[i].code}"));
                        }
                    }

                }
                else
                {
                    classroom = await client.GetContainer("TEAMModelOS", "Teacher").DeleteItemAsync<Classroom>(id.ToString(), new PartitionKey($"Class-{school_code}"));
                }
                return Ok(new { classroom });
            }
            catch (Exception ex)
            {
                return BadRequest();
            }
            
            
            //ResponseBuilder builder = ResponseBuilder.custom();
            /*List<IdPk> idPks = new List<IdPk>();
			if (request.TryGetProperty("id", out JsonElement id))
			{
				List<Classroom> sc = await _azureCosmos.FindByDict<Classroom>(request);
				if (sc.IsNotEmpty())
				{
					await _azureCosmos.DeleteAll<ClassStudent>(new Dictionary<string, object> { { "id", sc.Select(x => x.code).ToArray() } });
					idPks = await _azureCosmos.DeleteAll<Classroom>(sc);
					//builder.Data(idPks);
				}
			}
			else
			{
				return Ok(new { erro = ResponseCode.PARAMS_ERROR, V = "参数未定义！" });
			}
			return Ok(new { idPks });*/
            /*List<VoteRecord> sc = await _azureCosmos.FindByDict<VoteRecord>(request);
			await _azureCosmos.DeleteAll<VoteRecord>(sc);
			return Ok();*/
            //await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "School").CreateItemAsync("", new PartitionKey($"Class-{code}"));
        }
    }
}