TEAMModelOS/TEAMModelAPI/Controllers/School/RoomController.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;
namespace TEAMModelAPI.Controllers
{
    [Route("school")]
    [ApiController]
    public class RoomController : 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; }
        public RoomController(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;
        }
        /// <summary>
        /// 获取物理教室列表
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-room-list")]
        [ApiToken(Auth = "1401", 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 = "1402", 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 = "教室不存在！" });
            }
        }

        public class RoomDto
        {
            public List<Room> rooms { get; set; } = new List<Room>();

        }

        /// <summary>
        /// 创建或更新教学班基本信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("upsert-room-infos")]
        [ApiToken(Auth = "1403", Name = "创建或更新教学班", RW = "W", Limit = false)]
        public async Task<IActionResult> UpsertRoomInfo(RoomDto json)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();

            var rooms = json.rooms ;
            List<Room> db_rooms = new List<Room>();
            List<Room> roomCreate = new List<Room>();
           
            School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
            string sql = $"select value(c) from c  where c.id in({string.Join(",", rooms.Select(x => $"'{x.id}'"))})";
            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                .GetItemQueryIterator<Room>(queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Room-{school}") }))
            {
                db_rooms.Add(item);
            }
            //不存在的教室,可以被直接创建
            var unexistRoomIds = rooms.Select(x=>x.id).Except(db_rooms.Select(x => x.id));
            foreach (var roomId in unexistRoomIds) {
                var room_web = rooms.Find(x => x.id.Equals(roomId));
                if (room_web != null) {
                    var room = new Room
                    {
                        id = room_web.id,
                        name = room_web.name,
                        code = $"Room-{school}",
                        pk = "Room",
                        no = room_web.no,
                        address = room_web.address,
                    };
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).CreateItemAsync(room, new PartitionKey(room.code));
                    roomCreate.Add(room);
                }
            }
            foreach (var room in db_rooms) {
                var room_web = rooms.Find(x => x.id.Equals(room.id));
                if (room_web != null)
                {
                    room.name = string.IsNullOrWhiteSpace(room_web.name) ? room.name : room_web.name;  
                    room.code = $"Room-{school}";
                    room.pk = "Room";
                    room.no =string.IsNullOrWhiteSpace(room_web.no)?room.no : room_web.no;
                    room.address = string.IsNullOrWhiteSpace(room_web.address) ? room.address : room_web.address; 
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync(room,room.id, new PartitionKey(room.code));
                        
                }
            }
            return Ok(new { roomUpdate= db_rooms, roomCreate= roomCreate });
        }
    }
}