TEAMModelOS/TEAMModelOS.Service/Syllabus/Implements/KnowledgeService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.Model.Syllabus.Dtos;
using TEAMModelOS.Model.Syllabus.Models;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.Service.Core.Implements;
using TEAMModelOS.Service.Syllabus.Interfaces;

namespace TEAMModelOS.Service.Syllabus.Implements
{
    public class KnowledgeService : BaseService, IKnowledgeService
    {
        public async Task<List<KnowledgePoint>> FindKnowledgePointByDict(KnowledgeDto knowledgePoint) {
            List<KnowledgePoint> points = await FindListByDict<KnowledgePoint>(knowledgePoint.PointParams);
            if (knowledgePoint.Periods.IsNotEmpty()) {
                HashSet<KnowledgePoint> knowledges = new HashSet<KnowledgePoint>();
                foreach (string period in knowledgePoint.Periods) {
                    if (!string.IsNullOrEmpty(period)) {
                        knowledges.UnionWith(points.Where(x => x.AdvicePeriodCode.Contains(period)).ToHashSet());
                    }
                }
                return knowledges.OrderBy(x=>x.Order).ToList();
            }
            return points.OrderBy(x => x.Order).ToList(); 
        }

        public async Task<List<KnowledgePoint>> FindKnowledgeBlockAndPointByDict(KnowledgeDto knowledgePoint) {
            List<KnowledgeBlock> blocks = await FindListByDict<KnowledgeBlock>(knowledgePoint.PointParams);
            List<KnowledgeBlockPoint> blockPoints = await FindListByDict<KnowledgeBlockPoint>(knowledgePoint.PointParams);
            HashSet<KnowledgeBlock> knowledges = new HashSet<KnowledgeBlock>();
            HashSet<KnowledgeBlockPoint> knowledgeBlocks = new HashSet<KnowledgeBlockPoint>();
            if (knowledgePoint.Periods.IsNotEmpty())
            {
               
                foreach (string period in knowledgePoint.Periods)
                {
                    if (!string.IsNullOrEmpty(period))
                    {
                        knowledges.UnionWith(blocks.Where(x => x.AdvicePeriodCode.Contains(period)).ToHashSet());
                        knowledgeBlocks.UnionWith(blockPoints.Where(x => x.AdvicePeriodCode.Contains(period)).ToHashSet());
                    }
                }
                //knowledges.OrderBy(x => x.Order).ToList();
               // knowledgeBlocks.OrderBy(x => x.Order).ToList();
            }
            return null; 
        }
    }
}