TEAMModelOS/TEAMModelOS/Controllers/Both/KnowledgeController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using System.Collections.Generic;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.Filter;
using TEAMModelOS.Models;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Extension;
using System.Text;
using System;
using Azure.Cosmos;
using TEAMModelOS.SDK.Models.Service;
using System.Linq;
using OfficeOpenXml;
namespace TEAMModelOS.Controllers.Both
{
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]

    [Route("knowledge")]
    [ApiController]
    public class KnowledgeController : ControllerBase
    {
        private readonly SnowflakeId _snowflakeId;
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly AzureRedisFactory _azureRedis;
        private readonly HttpTrigger _httpTrigger;
        public KnowledgeController(HttpTrigger httpTrigger, AzureCosmosFactory azureCosmos, SnowflakeId snowflakeId, DingDing dingDing, IOptionsSnapshot<Option> option, AzureRedisFactory azureRedis)
        {
            _azureCosmos = azureCosmos;
            _snowflakeId = snowflakeId;
            _dingDing = dingDing;
            _option = option?.Value;
            _azureRedis = azureRedis;
            _httpTrigger = httpTrigger;
        }
        [ProducesDefaultResponseType]
        [HttpPost("import")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif
        [AuthToken(Roles = "admin", Permissions = "knowledge-upd")]
        public IActionResult ItemImport([FromForm] IFormFile file)
        {
            var tokenAuth = HttpContext.GetAuthTokenInfo();
            ExcelPackage.LicenseContext = OfficeOpenXml.LicenseContext.NonCommercial;
            List<dynamic> period_subject = new List<dynamic>();
            List<MoofenKnowledgePointDto> pointDtos = new List<MoofenKnowledgePointDto>();
            List<string> titles = new List<string>();
            List<List<string>> datas = new List<List<string>>();
            using (ExcelPackage package = new ExcelPackage(file.OpenReadStream()))
            {
                ExcelWorksheets sheets = package.Workbook.Worksheets;
                var sheet = sheets.FirstOrDefault();
                if (sheet!= null)
                {

                    var rows = sheet.Dimension.Rows;
                    var columns = sheet.Dimension.Columns;
                    for (int r = 1; r <= rows; r++)
                    {
                        List<string> data = new List<string>();
                        for (int c = 1; c <= columns; c++)
                        {
                            var value = sheet.GetValue(r, c);
                            if (r == 1)
                            {
                                if (!string.IsNullOrWhiteSpace($"{value}"))
                                {
                                    titles.Add($"{value}");
                                }
                                else
                                {
                                    break;
                                }
                            }
                            else
                            {
                                if (c > titles.Count)
                                {
                                    break;
                                }
                                else
                                {
                                    data.Add($"{value}");
                                }
                            }
                        }
                        if (data.Any())
                        {
                            datas.Add(data);
                        }
                    }
                }
            }
            int index = 1;
            foreach (var data in datas)
            {
                MoofenKnowledgePointDto knowledgePointDto = new MoofenKnowledgePointDto { kp1 = data[0], kp2= data[1], kp3 = data[2], kp4=  data[3], id=$"{index}" };
                if (!string.IsNullOrWhiteSpace(knowledgePointDto.kp1))
                {
                    knowledgePointDto.level=1;
                    knowledgePointDto.name=knowledgePointDto.kp1;
                }
                if (!string.IsNullOrWhiteSpace(knowledgePointDto.kp2))
                {
                    knowledgePointDto.level=2;
                    knowledgePointDto.name=knowledgePointDto.kp2;
                }
                if (!string.IsNullOrWhiteSpace(knowledgePointDto.kp3))
                {
                    knowledgePointDto.level=3;
                    knowledgePointDto.name=knowledgePointDto.kp3;
                }
                if (!string.IsNullOrWhiteSpace(knowledgePointDto.kp4))
                {
                    knowledgePointDto.level=4;
                    knowledgePointDto.name=knowledgePointDto.kp4;
                }
                pointDtos.Add(knowledgePointDto);
                index++;
            } // 构建树形结构
            var tree = KnowledgeService.BuildTree(pointDtos);
            tree.name=$"{file.FileName}";
            KnowledgeTreeDto knowledge = new KnowledgeTreeDto()
            {
                name=tree.name,
                tree= tree.children,
            };
            return Ok(new { knowledgeTree =knowledge});
        }

        [ProducesDefaultResponseType]
        [HttpPost("read")]
#if !DEBUG

        [Authorize(Roles = "IES")]
       [AuthToken(Roles = "teacher,admin,student", Permissions = "knowledge-read,knowledge-upd")]
#endif 
        public async Task<IActionResult> ReadKnowledge(JsonElement json)
        {
            var client = _azureCosmos.GetCosmosClient();
            var tokenAuth =  HttpContext.GetAuthTokenInfo();
            string scope = "school";
            if (json.TryGetProperty("scope", out JsonElement _scope)) 
            {
                scope=$"{scope}";
            }
            List<Knowledge> knowledges = new List<Knowledge>();
            string code = string.Empty;
            List<string> keywords = new List<string>();
            if (scope.Equals("school"))
            {
                json.TryGetProperty("periodId", out JsonElement periodId);
                if (!json.TryGetProperty("subjectId", out JsonElement subjectId)) return BadRequest();
                string school=string.Empty;
                if (string.IsNullOrWhiteSpace(tokenAuth.school))
                {
                    if (json.TryGetProperty("school_code", out JsonElement school_code))
                    {
                        school=$"{school_code}";
                    }
                }
                else {
                    school=tokenAuth.school;   
                }
                code = $"Knowledge-{school}-{subjectId}";
                StringBuilder sql = new StringBuilder($"select value(c) from c");
                if (periodId.ValueKind.Equals(JsonValueKind.String))
                {
                    sql.Append($" where c.periodId = '{periodId}'");
                }
               
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, Constant.School).GetItemQueryIterator<Knowledge>(queryText: sql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"{code}") }))
                {
                    item.blocks.ForEach(x =>
                    {
                        if (x.points == null)
                        {
                            x.points = keywords;
                        }
                    });
                    knowledges.Add(item);
                }
            }
            else {
                code=$"Knowledge-{tokenAuth.id}";
                StringBuilder sql = new StringBuilder($"select value(c) from c");
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS,Constant.Teacher).GetItemQueryIterator<Knowledge>(queryText: sql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"{code}") }))
                {
                    item.blocks.ForEach(x =>
                    {
                        if (x.points == null)
                        {
                            x.points = keywords;
                        }
                    });
                    knowledges.Add(item);
                }
            }
            return Ok(new { knowledgeTrees = KnowledgeService. KnowledgeTranslate(knowledges) });
        }

      
        [ProducesDefaultResponseType]
        [HttpPost("modify")]
#if !DEBUG

        [Authorize(Roles = "IES")]
        [AuthToken(Roles = "admin", Permissions = "knowledge-upd")]
#endif 
        public async Task<IActionResult> ModifyKnowledgeNode(JsonElement json)
        {
            List<TagOldNew> old_new = null;
            if (json.TryGetProperty("old_new", out JsonElement _old_new))
            {
                old_new = _old_new.ToObject<List<TagOldNew>>();
            }
            string id = json.GetProperty("id").GetString();
            string scope = json.GetProperty("scope").GetString();
            string owner = json.GetProperty("owner").GetString();
            string code =string.Empty;
            string tbname = string.Empty;
            string subjectId=string.Empty;
            int updateRel = json.GetProperty("updateRel").GetInt32();
            List<TagOldNew> updateData = new List<TagOldNew>();
            if ($"{scope}".Equals("school"))
            {
                subjectId = json.GetProperty("subjectId").GetString();
                code = $"Knowledge-{owner}-{subjectId}";
                tbname= Constant.School;
            }
            else {
                code=$"Knowledge-{owner}";
                tbname= Constant.Teacher;
            }
            Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).ReadItemStreamAsync(id, new PartitionKey(code));
            if (response.Status==200) 
            {
                bool change = false;
                Knowledge knowledge = JsonDocument.Parse(response.Content).RootElement.ToObject<Knowledge>();
                foreach(TagOldNew  tagOldNew in old_new) 
                {
                    if(!string.IsNullOrWhiteSpace(tagOldNew._id) && !string.IsNullOrEmpty(tagOldNew._old)  &&! string.IsNullOrWhiteSpace(tagOldNew._new)  && !tagOldNew._old.Equals(tagOldNew._new)) 
                    {
                       var node =  knowledge.nodes.Find(x =>!string.IsNullOrWhiteSpace(x.name)  &&  x.id.Equals(tagOldNew._id) && tagOldNew._old.Equals(x.name));
                        node.name= tagOldNew._new;
                        updateData.Add(tagOldNew);
                        change = true;
                    }
                    if (  !string.IsNullOrEmpty(tagOldNew._old)  &&!string.IsNullOrWhiteSpace(tagOldNew._new)  && !tagOldNew._old.Equals(tagOldNew._new))
                    {
                        var rsp= knowledge.points.Remove(tagOldNew._old);
                        if (rsp) {
                            change=true;
                            knowledge.points.Add(tagOldNew._new);
                        }
                        foreach (var block in knowledge.blocks) {
                            if (block.source!=1) 
                            {
                              var rsb= block.points.Remove(tagOldNew._old);
                                if (rsb) {
                                    block.points.Add(tagOldNew._new);
                                    change=true;
                                }
                            }
                        }
                    }
                }
                if (change) {
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).UpsertItemAsync(knowledge, new PartitionKey(code));
                }
                if (updateData.IsNotEmpty() &&updateRel==1)
                {
                    try
                    {
                        _ = _httpTrigger.RequestHttpTrigger(new { old_new = old_new, owner = $"{owner}", scope = $"{scope}", subjectId = $"{subjectId}" }, _option.Location, "knowledge-change");
                    }
                    catch (Exception ex)
                    {
                        //暂不处理
                    }
                }
                var dto =  KnowledgeService.KnowledgeTranslate(knowledge);
                return Ok(new { knowledgeTree = dto});
            }
            return Ok(new {code =404});
        }


        [ProducesDefaultResponseType]
        [HttpPost("upsert")]
#if !DEBUG

        [Authorize(Roles = "IES")]
        [AuthToken(Roles = "admin", Permissions = "knowledge-upd")]
#endif 
        public async Task<IActionResult> UpsertKnowledge(JsonElement json) 
        {
            KnowledgeTreeDto knowledge = json.GetProperty("knowledge").ToObject<KnowledgeTreeDto>();
            
            ValidResult validResult = knowledge.Valid();
            if (!validResult.isVaild)
            {
                return BadRequest(validResult);
            }
            var client = _azureCosmos.GetCosmosClient();

            string code = string.Empty;
            Knowledge old =  null;
            Knowledge knowledgeDb=null;
            var blocks = new List<Block>(); 
            var points = new HashSet<string>();
            var nodes = new List<PointNode>();
            KnowledgeService.TreeToList(knowledge.tree, nodes, blocks, points);
            if (knowledge.scope.Equals("school"))
            {
                if (!string.IsNullOrWhiteSpace(knowledge.subjectId)  && !string.IsNullOrWhiteSpace(knowledge.periodId))
                {
                    code = $"Knowledge-{knowledge.owner}-{knowledge.subjectId}";
                    StringBuilder sql = new StringBuilder($"select value c  from c where c.periodId = '{knowledge.periodId}'");
                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<Knowledge>
                        (queryText: sql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey(code) }))
                    {
                        old = item;
                        break;
                    }
                    if (old!=null)
                    {
                        knowledge.id = old.id;
                        knowledge.points=old.points;
                        knowledge.blocks=old.blocks;
                        foreach (var p in old.points)
                        {
                            points.Add(p);
                        }
                        foreach (var b in old.blocks)
                        {
                            var bks = blocks.FindAll(x => x.name.Equals(b.name));
                            if (bks.IsNotEmpty())
                            {
                                foreach (var bk in bks)
                                {
                                    bk.points.AddRange(b.points);
                                    bk.points= bk.points.Distinct().ToList();
                                }
                            }
                            else
                            {
                                blocks.Add(b);
                            }
                        }
                    }
                    else
                    {
                        knowledge.id = Guid.NewGuid().ToString();
                    }
                    knowledgeDb = new Knowledge
                    {
                        id=knowledge.id,
                        code=code,
                        name=knowledge.name,
                        periodId=knowledge.periodId,
                        subjectId   =knowledge.subjectId,
                        scope=knowledge.scope,
                        blocks=knowledge.blocks,
                        pk="Knowledge",
                        points=knowledge.points.ToList(),
                        nodes=nodes,
                        owner=knowledge.owner,
                    };
                    var count = new { pcount = points.Count, bcount = blocks.Count,name =knowledge.name };
                    //处理知识点，知识块计数问题
                    string key = $"KnowledgeNew:Count:{knowledge.owner}-{knowledge.periodId}";
                    string filed = knowledge.subjectId;
                    await _azureRedis.GetRedisClient(8).HashSetAsync(key, filed, count.ToJsonString());
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync(knowledgeDb, new PartitionKey(code));
                }
                else {
                    return BadRequest();
                }
            }
            else 
            {
                code=$"Knowledge-{knowledge.owner}";
                if (!string.IsNullOrWhiteSpace(knowledge.id)) 
                {
                    Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(knowledge.id, new PartitionKey(code));
                    if (response.Status!=200) 
                    {
                        knowledge.id = Guid.NewGuid().ToString();
                    }
                }
                  knowledgeDb = new Knowledge
                {
                    id=knowledge.id,
                    code=code,
                    name=knowledge.name,
                    periodId=knowledge.periodId,
                    subjectId   =knowledge.subjectId,
                    scope=knowledge.scope,
                    //blocks=blocks,
                    pk="Knowledge",
                   // points=points.ToList(),
                    nodes=nodes,
                    owner=knowledge.owner,
                };
                //处理知识点，知识块计数问题
                string key = $"KnowledgeNew:Count:{knowledge.owner}";
                string filed = knowledge.id;
                var count = new { pcount = points.Count, bcount = blocks.Count, name = knowledge.name };
                await _azureRedis.GetRedisClient(8).HashSetAsync(key, filed, count.ToJsonString());
                await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).UpsertItemAsync(knowledgeDb, new PartitionKey(code));
               
            }
            if (knowledgeDb!=null)
            {
                var dto = KnowledgeService.KnowledgeTranslate(knowledgeDb);
                return Ok(new { knowledgeTree = dto });
            }
            else {
                return BadRequest();
            }
        }
        [ProducesDefaultResponseType]
        [HttpPost("list")]
#if !DEBUG
        [Authorize(Roles = "IES")]
#endif
        [AuthToken(Roles = "teacher,admin,student", Permissions = "knowledge-read,knowledge-upd")]
        public async Task<IActionResult> FindCount(JsonElement json)
        {
            var (userid, _, _, school) = HttpContext.GetAuthTokenInfo();
            if (!json.TryGetProperty("scope", out var _scope)) {
                return BadRequest();
            }
            List<KnowledgeCount> datas = new List<KnowledgeCount>();
            if ($"{_scope}".Equals("school", StringComparison.OrdinalIgnoreCase))
            {
                if (!json.TryGetProperty("periodId", out var periodId))
                {
                    return BadRequest();
                }
                School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>(school, new PartitionKey("Base"));
                var period = schoolBase.period.Find(x => x.id.Equals($"{periodId}", StringComparison.OrdinalIgnoreCase));
                var values = await _azureRedis.GetRedisClient(8).HashGetAllAsync($"KnowledgeNew:Count:{period.id}");
                if (values!=null  && values!=default && values.Length>0)
                {
                    foreach (var value in values)
                    {

                        KnowledgeCount record = value.Value.ToString().ToObject<KnowledgeCount>();
                        record.periodId=period.id;
                        record.subjectId=value.Name;
                        record.owner=school;
                        record.scope="school";
                        datas.Add(record);
                    }
                }
                foreach (var subject in period.subjects) 
                {
                    var record = datas.Find(x => x.subjectId.Equals(subject.id));
                    if (record!=null)
                    {
                        record.name= subject.name;
                    }
                    else {
                        string   sql= $" select value c from c where c.subjectId='{subject.id}' and c.periodId='{period.id}'  ";
                        var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).GetList<Knowledge>(sql, $"Knowledge-{school}-{subject.id}");
                        if (result.list.IsNotEmpty())
                        {
                            foreach (var item in result.list) {
                                var dto = KnowledgeService.KnowledgeTranslate(item);
                                var count = new { pcount = dto.points.Count(), bcount = dto.blocks.Count(), name = subject.name };
                                //处理知识点，知识块计数问题
                                string key = $"KnowledgeNew:Count:{item.owner}-{item.periodId}";
                                string filed = item.subjectId;
                                await _azureRedis.GetRedisClient(8).HashSetAsync(key, filed, count.ToJsonString());
                                 record = new KnowledgeCount
                                {
                                     id= item.id,
                                     periodId=period.id,
                                     subjectId=subject.id,
                                     name=subject.name,
                                     owner=school,
                                     scope="school",
                                     pcount=dto.points.Count(),
                                     bcount=dto.blocks.Count(),
                                };
                                datas.Add(record);
                                break;
                            }
                        }
                        else {
                            record = new KnowledgeCount
                            {
                                periodId=period.id,
                                subjectId=subject.id,
                                name=subject.name,
                                owner=school,
                                scope="school",
                                pcount=0,
                                bcount=0,
                            }; 
                            datas.Add(record);
                        }
                    }
                }
            }
            else {
                var values = await _azureRedis.GetRedisClient(8).HashGetAllAsync($"KnowledgeNew:Count:{userid}");
                if (values!=null  && values!=default && values.Length>0)
                {
                    foreach (var value in values)
                    {

                        KnowledgeCount record = value.Value.ToString().ToObject<KnowledgeCount>();
                        record.id=value.Name;
                        record.owner=userid;
                        record.scope="private";
                        datas.Add(record);
                    }
                }
                string sql = string.Empty;
                if (datas.IsNotEmpty())
                {
                    sql= $" select value c from c where c.id not in ({string.Join(",", datas.Select(x => $"'{x.id}'"))}) ";
                }
                else {
                    sql= $" select value c from c ";
                }
                var result =  await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetList<Knowledge>(sql, $"Knowledge-{userid}");
                if (result.list.IsNotEmpty()) 
                {
                    foreach (var item in result.list) 
                    {
                       var dto= KnowledgeService.KnowledgeTranslate(item);

                        //处理知识点，知识块计数问题
                        string key = $"KnowledgeNew:Count:{item.owner}";
                        string filed = item.id;
                        var count = new { pcount = dto. points.Count(), bcount = dto.blocks.Count(), name = item.name };
                        await _azureRedis.GetRedisClient(8).HashSetAsync(key, filed, count.ToJsonString());
                        KnowledgeCount record = new KnowledgeCount
                        {
                            id=item.id,
                            name=item.name,
                            owner=userid,
                            scope="private",
                            pcount=dto.points.Count(),
                            bcount=dto.blocks.Count(),
                        };
                        datas.Add(record);
                    }
                }
            }
            return Ok(new { datas });
        }
    }
}