TEAMModelOS/TEAMModelOS/Controllers/Syllabus/ItemInfoController.cs

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.DI;
using System.Text.Json;
using TEAMModelOS.SDK.Helper.Common.StringHelper;
using TEAMModelOS.Models.CommonInfo;
using Microsoft.AspNetCore.Http;
using TEAMModelOS.SDK.Extension;
using Azure.Cosmos;
using Microsoft.AspNetCore.Authentication;
using System.Text;
using TEAMModelOS.SDK.DI.AzureCosmos.Inner;

namespace TEAMModelOS.Controllers
{
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    //[Authorize(Roles = "IES5")]
    [Route("common/item")]
    //[Route("api/[controller]")]
    [ApiController]
    public class ItemInfoController : ControllerBase
    {
        private readonly SnowflakeId _snowflakeId;
        private readonly AzureCosmosFactory _azureCosmos;
        public ItemInfoController(AzureCosmosFactory azureCosmos, SnowflakeId snowflakeId)
        {
            _azureCosmos = azureCosmos;
            _snowflakeId = snowflakeId;
        }

        /// <summary>
        /// 批量保存题目
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("upsert-all")]
        public async Task<IActionResult> UpsertAll(List<ItemInfo> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            
            request.ForEach(x => {
              
                if (string.IsNullOrEmpty(x.id)) {
                    x.id = _snowflakeId.NextId()+"";
                    x.code = typeof(ItemInfo).Name + "-" + x.code;
                };
                x.createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
            });
            return Ok(await _azureCosmos.SaveOrUpdateAll(request));
        }
        [ProducesDefaultResponseType]
        [HttpPost("upsert")]
        public async Task<IActionResult> Upsert(ItemInfo request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();                          
            if (string.IsNullOrEmpty(request.id))
            {
                request.id = _snowflakeId.NextId() + "";
                request.code = typeof(ItemInfo).Name + "-" + request.code;
            };
            request.createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
            return Ok(await _azureCosmos.SaveOrUpdate(request));
        }
        /// <summary>
        //获取题目摘要信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("find-summary")]
        public async Task<IActionResult> FindSummary(JsonElement requert)
        {

            var client = _azureCosmos.GetCosmosClient();
            StringBuilder sql = new StringBuilder();
            sql.Append("select c.id, c.question,c.usageCount,c.level,c.field,c.points,c.type,c.option,c.createTime from c ");
            if (!requert.TryGetProperty("code", out JsonElement code)) return BadRequest();
            if (!requert.TryGetProperty("@CURRPAGE", out JsonElement page)) return BadRequest();
            if (!requert.TryGetProperty("@PAGESIZE", out JsonElement size)) return BadRequest();
            if (!requert.TryGetProperty("@DESC", out JsonElement desc)) return BadRequest();
            List<object> summary = new List<object>();
            AzureCosmosQuery cosmosDbQuery = SQLHelper.GetSQL(requert,sql);
            await foreach (var item in client.GetContainer("TEAMModelOS", "Common").GetItemQueryStreamIterator(queryDefinition: cosmosDbQuery.CosmosQueryDefinition, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"ItemInfo-{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())
                    {
                        summary.Add(obj.ToObject<object>());
                    }
                }
            }


            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            /*var emobj = requert.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            //if (!requert.TryGetProperty("code", out JsonElement code)) return BadRequest();
            List<string> props = new List<string> {
                "question", "id", "code", "usageCount",
                "level","field","points","type","option","createTime"
            };
            List<ItemInfo> items = new List<ItemInfo>();
            if (dict.Keys.Count > 0)
            {
                items = await _azureCosmos.FindByDict<ItemInfo>(requert, propertys: props);
            }*/
            return Ok(new { summary });
            //return builder.Data(items).Extend(new Dictionary<string, object> { { "props", props } }).build();
        }
        /// <summary>
        /// 手动挑题
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("find-by-ids")]
        public async Task<IActionResult> FindByIds(List<string> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            List<ItemInfo> items = await _azureCosmos.FindByIds<ItemInfo>(request);
            return Ok(items);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("delete")]
        public async Task<IActionResult> Delete(IdPk request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            IdPk idPk = await _azureCosmos.DeleteAsync<ItemInfo>( request );
            return Ok(idPk);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("delete-all")]
        public async Task<IActionResult> DeleteAll(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            List<IdPk> idPk = await _azureCosmos.DeleteAll<ItemInfo>(request);
            return Ok(idPk);
        }
        /// <summary>
        /// 手动挑题
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("find")]
        public async Task<IActionResult> Find(JsonElement requert)
        {
            var client = _azureCosmos.GetCosmosClient();
            StringBuilder sql = new StringBuilder();
            sql.Append("select c.id, c.question,c.usageCount,c.level,c.field,c.points,c.type,c.option,c.createTime,c.answer,c.explain,c.children,c.score,c.order,c.gradeCode from c ");
            if (!requert.TryGetProperty("code", out JsonElement code)) return BadRequest();
            if (!requert.TryGetProperty("@CURRPAGE", out JsonElement page)) return BadRequest();
            if (!requert.TryGetProperty("@PAGESIZE", out JsonElement size)) return BadRequest();
            if (!requert.TryGetProperty("@DESC", out JsonElement desc)) return BadRequest();
            AzureCosmosQuery cosmosDbQuery = SQLHelper.GetSQL(requert, sql);
            List<object> items = new List<object>();
            await foreach (var item in client.GetContainer("TEAMModelOS", "Common").GetItemQueryStreamIterator(queryDefinition: cosmosDbQuery.CosmosQueryDefinition, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"ItemInfo-{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())
                    {
                        items.Add(obj.ToObject<object>());
                    }
                }
            }


            //ResponseBuilder builder = ResponseBuilder.custom();
            /* List<ItemInfo> items = new List<ItemInfo>();
             if (StringHelper.getKeyCount(requert) > 0)
             {
                 items = await _azureCosmos.FindByDict<ItemInfo>(requert);
             }*/
            return Ok(new { items });
            //return builder.Data(items).build();
        }

        /// <summary>
        /// 手动挑题
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("Find-cache-shell")]
        public async Task<IActionResult> FindCacheShell(JsonElement requert)
        {
            var client = _azureCosmos.GetCosmosClient();
            if (!requert.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
            if (!requert.TryGetProperty("ids", out JsonElement id)) return BadRequest();
            //List<string> ids = new List<string>();
            string info = "";
            for (int i = 0; i < id.GetArrayLength(); i++) {
                //ids.Add(id[i].ToJsonString());
                info += id[i].ToJsonString() + ",";
            }
            List<object> items = new List<object>();
            var query = $"select c.id, c.question,c.usageCount,c.level,c.field,c.points,c.type,c.option,c.createTime from c where c.id in ({info[0..^1]})";
            await foreach (var item in client.GetContainer("TEAMModelOS", "Common").GetItemQueryStreamIterator(queryText: query, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"ItemInfo-{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())
                    {
                        items.Add(obj.ToObject<object>());
                    }
                }
            }

            return Ok(new { items });
           /* ResponseBuilder builder = ResponseBuilder.custom();
            List<ItemInfo> items = await _azureCosmos.FindByIds<ItemInfo>(request);
            //List<string> ps = new List<string>() { "6f705b1b-8221-5307-18da-13da05adf91e", "c3e1e95a-561e-fabf-cce3-3a564782e443" };
            //
            //
            //Random random = new Random();
            //items.ForEach(x => { x.usageCount = random.Next(0, 300);x.createTime = random.Next(1426668584, 1584521384);x.order = random.Next(1, items.Count); });
            //await cosmosDBV3Repository.SaveOrUpdateAll(items);
            return builder.Data(items).build();*/
        }

        /// <summary>
        /// 自动组题
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("Automatic")]
        public async Task<IActionResult> Automatic(Compose request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();

            ///处理知识点均分问题
            int avg = 0;
            Dictionary<string, int> point = new Dictionary<string, int>();
            if (request.points.IsNotEmpty())
            {
                avg = (int)Math.Ceiling(request.count * 1.0 / request.points.Count);

                foreach (string p in request.points)
                {
                    point.TryAdd(p, avg);
                }
            }
            List<ItemInfo> retnInfos = new List<ItemInfo>();
            List<ItemInfo> itemInfos = new List<ItemInfo>();
            List<TempItem> tempItems = new List<TempItem>();
            if (request.quInfos.IsNotEmpty())
            {
                List<string> types = new List<string>();
                List<int> levels = new List<int>();
                foreach (QuInfo quInfo in request.quInfos)
                {
                    // 自定义
                    if (quInfo.custom.IsNotEmpty() && quInfo.policy.Equals("custom"))
                    {
                        foreach (Custom custom in quInfo.custom)
                        {
                            for (int i = 0; i < custom.count; i++)
                            {
                                tempItems.Add(new TempItem { level = custom.level, type = quInfo.type });
                            }
                            Dictionary<string, object> dict = new Dictionary<string, object>();
                            if (request.code.IsNotEmpty())
                            {
                                dict.Add("code", request.code.ToArray());
                            }
                            if (request.period.IsNotEmpty())
                            {
                                dict.Add("period", request.period.ToArray());
                            }
                            if (request.points.IsNotEmpty())
                            {
                                dict.Add("points[*]", request.points.ToArray());
                            }
                            dict.Add("lite", false);
                            ///
                            dict.Add("type", quInfo.type);
                            dict.Add("level", custom.level);
                            List<ItemInfo> items = await _azureCosmos.FindByDict<ItemInfo>(dict);
                            //id去重
                            items = items.Where((x, i) => items.FindIndex(z => z.id == x.id) == i).ToList();
                            ////均分知识点题目
                            itemInfos.AddRange(items);
                        }
                    }
                    else
                    {
                        Dictionary<string, object> dict = new Dictionary<string, object>();
                        if (request.code.IsNotEmpty())
                        {
                            dict.Add("code", request.code.ToArray());
                        }
                        if (request.period.IsNotEmpty())
                        {
                            dict.Add("period", request.period.ToArray());
                        }
                        if (request.points.IsNotEmpty())
                        {
                            dict.Add("points[*]", request.points.ToArray());
                        }
                        dict.Add("lite", false);
                        dict.Add("type", quInfo.type);
                        List<ItemInfo> items = await _azureCosmos.FindByDict<ItemInfo>(dict);
                        //id去重
                        items = items.Where((x, i) => items.FindIndex(z => z.id == x.id) == i).ToList();
                        itemInfos.AddRange(items);
                        //均分
                        if (quInfo.policy.Equals("average"))
                        {
                            //按等级去重 获取所有等级
                            List<int> lvls = items.Where((x, i) => items.FindIndex(z => z.level == x.level) == i).Select(x => x.level).ToList();
                            foreach (int i in lvls)
                            {
                                int count = quInfo.count / lvls.Count;
                                for (int j = 0; j < count; j++)
                                {
                                    tempItems.Add(new TempItem { level = i, type = quInfo.type });
                                }
                            }
                            //  余数 取模 随机处理
                            if (lvls.Count != 0)
                            {
                                int mod = quInfo.count % lvls.Count;
                                for (int m = 0; m < mod; m++)
                                {
                                    int lv = lvls.OrderBy(x => Guid.NewGuid()).Take(1).FirstOrDefault();
                                    tempItems.Add(new TempItem { level = lv, type = quInfo.type });
                                    lvls.Remove(lv);
                                }
                            }
                        }
                        //随机
                        if (quInfo.policy.Equals("random"))
                        {
                            List<int> lvls = items.Where((x, i) => items.FindIndex(z => z.level == x.level) == i).Select(x => x.level).ToList();
                            for (int n = 0; n < quInfo.count; n++)
                            {
                                int lv = lvls.OrderBy(x => Guid.NewGuid()).FirstOrDefault();
                                tempItems.Add(new TempItem { level = lv, type = quInfo.type });
                            }
                        }
                    }
                }
            }
            itemInfos = itemInfos.OrderBy(x => Guid.NewGuid()).ToList();
            tempItems = tempItems.OrderBy(x => Guid.NewGuid()).ToList();
            foreach (TempItem temp in tempItems)
            {
                ItemInfo itemInfo = itemInfos.Where(x => x.level == temp.level && x.type == temp.type).OrderBy(x => Guid.NewGuid()).FirstOrDefault();
                if (itemInfo != null)
                {
                    retnInfos.Add(itemInfo);
                    itemInfos.Remove(itemInfo);
                }
            }
            List<List<ItemInfo>> listInfo = new List<List<ItemInfo>>();
            foreach (IGrouping<string, ItemInfo> group in retnInfos.GroupBy(c => c.type))
            {
                Dictionary<string, object> dictInfo = new Dictionary<string, object>();
                listInfo.Add(group.ToList());
            }
            List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
            foreach (List<ItemInfo> infos in listInfo)
            {
                List<Dictionary<string, object>> dict = new List<Dictionary<string, object>>();
                foreach (IGrouping<int, ItemInfo> group in infos.GroupBy(c => c.level))
                {
                    Dictionary<string, object> dictInfo = new Dictionary<string, object>();
                    dictInfo.Add("level", group.Key);
                    dictInfo.Add("count", group.Count());
                    dict.Add(dictInfo);
                }
                Dictionary<string, object> typeDict = new Dictionary<string, object>();
                typeDict.Add("info", dict);
                typeDict.Add("item", infos);
                typeDict.Add("count", infos.Count);
                typeDict.Add("type", infos.FirstOrDefault().type);
                list.Add(typeDict);
            }
            //return builder.Data(list).build();
            return Ok(list);
        }
    }

    public class TempItem
    {
        public string type { get; set; }
        public int level { get; set; }
        public ItemInfo itemInfo { get; set; }
    }


    public class Compose
    {
        /// <summary>
        /// 科目
        /// </summary>
        public string subject { get; set; }
        /// <summary>
        /// 来源，个人题库，校本题库
        /// </summary>
        public List<string> code { get; set; }
        /// <summary>
        /// 适用学段，小学，初中，高中
        /// </summary>
        public List<string> period { get; set; }
        /// <summary>
        /// 关联知识点
        /// </summary>
        public List<string> points { get; set; }
        /// <summary>
        /// 题目组合
        /// </summary>
        public List<QuInfo> quInfos { get; set; }
        /// <summary>
        /// 题目总数
        /// </summary>
        public int count { get; set; }
    }
    public class QuInfo
    {
        /// <summary>
        /// 题目类型，单选，多选，判断，填空，问答，综合  Single单选，Multiple多选，Judge判断，Complete填空，Subjective问答，Compose综合
        /// </summary>
        public string type { get; set; }
        /// <summary>
        /// 随机 random  平均的 average ,自定义 custom
        /// </summary>
        public string policy { get; set; }
        /// <summary>
        /// 自定义题目类型
        /// </summary>
        public List<Custom> custom { get; set; }
        /// <summary>
        /// 总题
        /// </summary>
        public int count { get; set; }
    }
    public class Custom
    {
        /// <summary>
        /// 难易程度
        /// </summary>
        public int level { get; set; }
        /// <summary>
        /// 数量
        /// </summary>
        public int count { get; set; }
    }
}