App_V2.3/SourceCode/WeApp.Application/BaseSystem/Query/QueryAppService.cs

using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Configuration;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;

using IwbZero.AppServiceBase;
using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.IO;
using System.Linq;
using System.Speech.Synthesis;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Mvc;

using WeApp.Authorization.Users;
using WeApp.BaseInfo;
using WeApp.BaseSystem.Query.Dto;
using WeApp.BaseSystem.Users.Dto;
using WeApp.BasicInfo;
using WeApp.BasicInfo.PhoneQuestion.Dto;
using WeApp.BasicInfo.TrainingRoleGroup.Dto;
using WeApp.Configuration;
using WeApp.Configuration.Cache;
using WeApp.TrainingCamp;
using WeApp.TrainingCamp.Dto;
using WeApp.TrainingCampGroup.Dto;
using WeApp.TrainingEval.Dto;

using WeEngine.ModelInfo;
using WeEngine.Packages;

namespace WeApp.BaseSystem.Query
{
    [AbpAllowAnonymous, DisableAuditing]
    public class QueryAppService : IwbAppServiceBase, IQueryAppService
    {
        #region 仓储

        public QueryAppService(
            IRepository<User, long> userRepository, IRepository<CampInfo, string> campRepository, IRepository<CampGroupInfo, string> groupRepository, IRepository<CampRelateGroupRoleInfo> cgrRepository, IRepository<TrainingGroupRelateRoleInfo> grrRepository, IRepository<GroupRoleInfo> groupRoleRepository, IRepository<TrainingRoleInfo, string> roleRepository, IRepository<GroupLogInfo> glRepository, IRepository<CampSceneMapInfo> sceneMapRepository, IRepository<SysAttachFile> attachRepository, IRepository<GroupScoreInfo> gsRepository, IRepository<PortraitRemarkInfo> prRepository, IRepository<PhoneAnswerInfo> answerRepository, IRepository<StudentHelpInfo, string> stuHelpRepository, IRepository<CampHelpInfo> campHelpRepository, IRepository<PhoneQuestionInfo, string> questionRepository)
        {
            UserRepository = userRepository;
            CampRepository = campRepository;
            GroupRepository = groupRepository;
            CgrRepository = cgrRepository;
            GrrRepository = grrRepository;
            GroupRoleRepository = groupRoleRepository;
            RoleRepository = roleRepository;
            GlRepository = glRepository;
            SceneMapRepository = sceneMapRepository;
            AttachRepository = attachRepository;
            GsRepository = gsRepository;
            PrRepository = prRepository;
            AnswerRepository = answerRepository;
            StuHelpRepository = stuHelpRepository;
            CampHelpRepository = campHelpRepository;
            QuestionRepository = questionRepository;
        }

        private string DataCenterUrl => SettingManager.GetSettingValue(IwbSettingNames.WeDataCenterIp).Ew("/");
        // private string EngineUrl => SettingManager.GetSettingValue(IwbSettingNames.WeDataCenterIp).Ew("/");

        protected IRepository<CampInfo, string> CampRepository { get; }
        protected IRepository<CampGroupInfo, string> GroupRepository { get; }
        protected IRepository<CampRelateGroupRoleInfo> CgrRepository { get; }
        protected IRepository<TrainingGroupRelateRoleInfo> GrrRepository { get; }
        protected IRepository<GroupRoleInfo> GroupRoleRepository { get; }
        protected IRepository<GroupScoreInfo> GsRepository { get; }
        protected IRepository<GroupLogInfo> GlRepository { get; }
        protected IRepository<TrainingRoleInfo, string> RoleRepository { get; }
        protected IRepository<User, long> UserRepository { get; }
        protected IRepository<PortraitRemarkInfo> PrRepository { get; }
        public IRepository<PhoneQuestionInfo, string> QuestionRepository { get; }
        public IRepository<PhoneAnswerInfo> AnswerRepository { get; }
        public IRepository<StudentHelpInfo, string> StuHelpRepository { get; }
        public IRepository<CampHelpInfo> CampHelpRepository { get; }

        protected IRepository<CampSceneMapInfo> SceneMapRepository { get; }

        protected IRepository<SysAttachFile> AttachRepository { get; }

        #endregion 仓储

        #region SELECT

        #region Camp && Group

        public async Task<List<SelectListItem>> GetCampStateSelectList()
        {
            var list = await StatesManager.GetSelectListAsync("Camp", "State");
            return list;
        }

        public async Task<string> GetCampStateSelectStr()
        {
            var str = await StatesManager.GetSelectListStrAsync("Camp", "State");
            str = "<option  value=\"\" selected >请选择培训营状态.</option>" + str;
            return str;
        }

        public async Task<string> GetCampStateSelectStr(params string[] states)
        {
            var str = await StatesManager.GetSelectListStrAsync("Camp", "State", a => states.Contains(a.CodeValue));
            str = "<option  value=\"\" selected >请选择培训营状态.</option>" + str;
            return str;
        }

        public async Task<List<SelectListItem>> GetCampGroupStateSelectList()
        {
            var list = await StatesManager.GetSelectListAsync("CampGroup", "State");
            return list;
        }

        public async Task<string> GetCampGroupStateSelectStr()
        {
            var str = await StatesManager.GetSelectListStrAsync("CampGroup", "State");
            return str;
        }

        public async Task<string> GetStuHelpSelectStr()
        {
            var list = await StuHelpRepository.GetAll().Select(a => new
            {
                a.Id,
                a.HelpName
            }).ToListAsync();
            var str = "";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l.Id}\">{l.HelpName}</option>";
            }
            return str;
        }

        public async Task<string> GetStuHelpContentSelectStrByCamp(string no)
        {
            var list = await CampHelpRepository.GetAllIncluding(a => a.HelpInfo).Where(a => a.CampNo == no).Select(a => new
            {
                a.HelpInfo.Id,
                a.HelpInfo.HelpName,
                a.HelpInfo.HelpContent
            }).ToListAsync();
            var str = "";//"<option  value=\"\" selected >请选择帮助信息...</option>";
            foreach (var l in list)
            {
                str += $"<option value=\"{l.Id}\">{l.HelpContent}</option>";
            }
            return str;
        }

        public async Task<string> GetCampSelectStr(params int[] states)
        {
            var list = await CampRepository.GetAllListAsync(a => states.Contains(a.CampState));
            var str = "<option  value=\"\" selected >请选择演练培训营...</option>";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l.Id}\"  >{l.Name}</option>";
            }
            return str;
        }

        public async Task<string> GetCampGroupSelectStr(string no)
        {
            var list = await GroupRepository.GetAllListAsync(a => a.CampNo == no);
            var str = "<option  value=\"\" selected >请选择培训营分组...</option>";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l.Id}\"  >{l.Name}</option>";
            }
            return str;
        }

        public async Task<string> GetGroupRoleSelectStr(string no)
        {
            var list = (await GroupRoleRepository.FirstOrDefaultAsync(a => a.GroupNo == no))?.RoleNames?.Split(',').ToList() ?? new List<string>();
            var str = "<option  value=\"\" selected >请选择角色...</option>";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l}\"  >{l}</option>";
            }
            return str;
        }

        #endregion Camp && Group

        /// <summary>
        /// 获取问题
        /// </summary>
        /// <returns></returns>
        public async Task<string> GetQuestionsSelectStr()
        {
            var list = await QuestionRepository.GetAllListAsync();
            var str = "<option  value=\"\" selected >请选择电话提问...</option>";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l.Id}\" title=\"{l.Content}\" >{l.Name}</option>";
            }
            return str;
        }

        /// <summary>
        /// PhoneQuestion类型
        /// </summary>
        /// <returns></returns>
        public async Task<string> GetQuestionTypeSelectStr()
        {
            var str = await StatesManager.GetSelectListStrAsync("PhoneQuestion", "Type");
            str = "<option  value=\"\" selected >请选择问题类型...</option>" + str;
            return str;
        }

        /// <summary>
        /// PhoneQuestion类型
        /// </summary>
        /// <returns></returns>
        public async Task<string> GetAnswerTypeSelectStr()
        {
            var str = await StatesManager.GetSelectListStrAsync("PhoneAnswer", "Type");
            str = "<option  value=\"\" selected >请选择答案类型...</option>" + str;
            return str;
        }

        /// <summary>
        /// 画像预置信息类型
        /// </summary>
        /// <returns></returns>
        public async Task<string> GetPortraitRemarkTypeSelectStr()
        {
            var str = await StatesManager.GetSelectListStrAsync("PortraitRemark", "Type");
            str = "<option  value=\"\" selected >请选择信息类型...</option>" + str;
            return str;
        }

        #region 用户

        [DisableAuditing]
        public async Task<List<SelectListItem>> GetUserSelectList()
        {
            var list = await UserRepository.GetAllListAsync();
            var sList = new List<SelectListItem> { new SelectListItem { Text = @"请选择用户...", Value = "", Selected = true } };
            foreach (var l in list)
            {
                sList.Add(new SelectListItem { Value = l.Id + "", Text = l.Name });
            }
            return sList;
        }

        [DisableAuditing]
        public async Task<string> GetUserSelectStr()
        {
            var list = await UserRepository.GetAllListAsync();
            var str = "<option  value=\"\" selected >请选择用户...</option>";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l.Id}\"  >{l.Name}</option>";
            }
            return str;
        }

        //[DisableAuditing]
        //public async Task<string> GetCategorySelectStr()
        //{
        //    var list = await CategoryRepository.GetAllListAsync();
        //    string str = "";//"<option  value=\"\" selected >请选择类别...</option>";
        //    var tempParentNo = list.FirstOrDefault(a => a.ParentNo == null)?.Id ?? "";
        //    foreach (var l in list)
        //    {
        //        var name = l.CategoryName;
        //        var parentNo = l.ParentNo;
        //        var id = l.Id;
        //        if (l.ParentNo == null)
        //        {
        //            parentNo = "0";
        //            id = "";
        //            name = "请选择类别";
        //        }
        //        else if (l.ParentNo == tempParentNo)
        //        {
        //            parentNo = "";
        //        }
        //        str += $"<option parent=\"{parentNo}\" value=\"{id}\">{name}</option>";
        //    }
        //    return str;
        //}

        #endregion 用户

        #endregion SELECT

        /// <summary>
        /// 查询用户信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<PagedResultDto<UserDto>> QueryUsers(IwbPagedRequestDto input)
        {
            var query = UserRepository.GetAll().Where(a => a.IsActive);
            query = ApplyFilter(query, input);
            var totalCount = await query.CountAsync();
            query = query.OrderBy(a => a.Id);
            query = query.Skip(input.SkipCount).Take(input.MaxResultCount);
            var entities = await query.ToListAsync();
            var dtoList = new PagedResultDto<UserDto>(totalCount, ObjectMapper.Map<List<UserDto>>(entities));
            return dtoList;
        }

        /// <summary>
        /// 查询培训营的分组
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<CampGroupDto>> GetCampGroups(string no)
        {
            var query = await GroupRepository.GetAllListAsync(a => a.CampNo == no);
            var list = query.Select(ObjectMapper.Map<CampGroupDto>).ToList();
            return list;
        }

        /// <summary>
        /// 获取培训的角色组预案
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<TrainingRoleGroupDto>> GetCampRoleGroupInfos(string no)
        {
            var roleGroups = await CgrRepository.GetAllIncluding(a => a.TrainingRoleGroupInfo).Where(a => a.CampNo == no).Select(a => a.TrainingRoleGroupInfo).ToListAsync();
            var dtoList = new List<TrainingRoleGroupDto>();
            foreach (var roleGroup in roleGroups)
            {
                var dto = ObjectMapper.Map<TrainingRoleGroupDto>(roleGroup);
                var roles = GrrRepository.GetAllIncluding(a => a.TrainingRoleInfo).Where(a => a.RoleGroupNo == dto.Id);
                dto.RoleNos = roles.Select(a => a.TrainRoleNo).ToList();
                dto.RoleNames = string.Join(",", roles.Select(a => a.TrainingRoleInfo.RoleName).ToArray());
                dtoList.Add(dto);
            }

            return dtoList;
        }

        /// <summary>
        /// 获取问题
        /// </summary>
        /// <returns></returns>
        public async Task<List<PhoneQuestionDto>> GetQuestions()
        {
            var list = await QuestionRepository.GetAllListAsync();
            return list.Select(ObjectMapper.Map<PhoneQuestionDto>).ToList();
        }

        /// <summary>
        /// 获取问题
        /// </summary>
        /// <returns></returns>
        public async Task<PhoneQuestionDto> GetQuestion(string no)
        {
            var entity = await QuestionRepository.FirstOrDefaultAsync(a => a.Id == no);
            return ObjectMapper.Map<PhoneQuestionDto>(entity);
        }

        /// <summary>
        /// 获取日志的电话问题
        /// </summary>
        /// <returns></returns>
        public async Task<PhoneQuestionDto> GetQuestionByLog(int no)
        {
            var log = await GlRepository.FirstOrDefaultAsync(a => a.Id == no);
            var entity = await QuestionRepository.FirstOrDefaultAsync(a => a.Id == log.ExtendInfo1);
            return ObjectMapper.Map<PhoneQuestionDto>(entity);
        }

        /// <summary>
        /// 获取带电话问题的日志
        /// </summary>
        /// <returns></returns>
        public async Task<List<int>> GetQuestionLogs(string no)
        {
            var logs = await GlRepository.GetAll().Where(a => a.GroupNo == no && a.LogCommand == LogCommandDefinition.PhoneQuestion && string.IsNullOrEmpty(a.ExtendInfo4)).Select(a => a.Id).ToListAsync();
            return logs;
        }

        /// <summary>
        /// 获取问题的答案
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<PhoneAnswerDto>> GetQuestionAnswers(string no)
        {
            var list = await AnswerRepository.GetAllListAsync(a => a.QuestionNo == no);
            return list.Select(ObjectMapper.Map<PhoneAnswerDto>).ToList();
        }

        /// <summary>
        /// 获取培训营学员提示
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<string>> GetStuHelpStrByCamp(string no)
        {
            var list = await CampHelpRepository.GetAllIncluding(a => a.HelpInfo).Where(a => a.CampNo == no).Select(a => a.HelpInfo.Id).ToListAsync();
            return list;
        }

        /// <summary>
        /// 预加载
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task LoadCampPre(string no, int type)
        {
            var camp = await GroupRepository.GetAllIncluding(a => a.CampInfo).Where(a => a.Id == no).Select(a => new CampDto { PackageNo = a.CampInfo.PackageNo }).FirstOrDefaultAsync();
            if (camp != null)
            {
                await Task.Run(() => { CacheManager.GetPackageDetail(camp.PackageNo, DataCenterUrl); });
                if (type != 0)
                {
                    await Task.Run(() => { CacheManager.GetPackageDataNode(camp.PackageNo, DataCenterUrl); });
                }
            }
        }

        /// <summary>
        /// 查询培训营分组的演练角色
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<string>> GetGroupRoleInfos(string no)
        {
            var entity = await GroupRoleRepository.FirstOrDefaultAsync(a => a.GroupNo == no);
            var list = entity?.RoleNames?.Split(',').ToList() ?? new List<string>();
            return list;
        }

        /// <summary>
        /// 查询培训营分组的演练角色预案
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<GroupRolePlanDto> GetGroupRolePlans(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.GroupInfoCache).GetAsync($"Plan-{no}", async () =>
            {
                var entity = await GroupRoleRepository.FirstOrDefaultAsync(a => a.GroupNo == no);
                if (entity == null)
                {
                    return null;
                }

                var plans = new List<RolePlanDto>();
                if (entity.RoleGroupNos != null)
                {
                    var nos = entity.RoleGroupNos.Split(',');
                    foreach (var n in nos)
                    {
                        var gr = await GrrRepository.GetAllIncluding(a => a.TrainingRoleInfo, a => a.RoleGroupInfo)
                            .Where(a => a.RoleGroupNo == n).ToListAsync();
                        if (gr.Any())
                        {
                            var name = gr[0].RoleGroupInfo.RoleGroupName;
                            var roles = gr.Select(a => a.TrainingRoleInfo.RoleName).ToList();
                            plans.Add(new RolePlanDto() { Name = name, RoleName = roles });
                        }
                    }
                }

                if (entity.CustomRoles.IsNotEmpty())
                {
                    plans.Add(new RolePlanDto()
                    {
                        Name = "自定义角色",
                        RoleName = entity.CustomRoles.Split(',').ToList()
                    });
                }

                return new GroupRolePlanDto() { GroupNo = no, Plans = plans };
            });
        }

        /// <summary>
        /// 查询培训营情景路径
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<PackageDataNode>> GetCampRunningInfos(string no)
        {
            var groupNos = await GroupRepository.GetAll().Where(a => a.CampNo == no).Select(a => a.Id).ToListAsync();
            var list = new List<PackageDataNode>();
            if (groupNos.Any())
            {
                foreach (var groupNo in groupNos)
                {
                    var runGroupInfo = await CacheManager.GetGroupRunningInfo(groupNo, GroupRepository);
                    if (runGroupInfo != null)
                    {
                        list.Add(runGroupInfo);
                    }
                }
            }
            return list;
        }

        /// <summary>
        /// 获取某组的情景路径
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<PackageDataNode> GetGroupRunningInfo(string no)
        {
            var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
            return runGroupInfo;
        }

        //private RunningInfo GetRunningInfo(string no)
        //{
        //    var url =
        //        $"{EngineUrl}api/services/Engine/Run/QueryRunningInfo?runningId={no}";
        //    var result = url.RequestPost("");
        //    var info = result.Str2Obj<RunningInfo>();
        //    return info;
        //}

        #region 日志

        /// <summary>
        /// 查询当前情景的处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<GroupRoleLogDto>> GetCurrentSceneLog(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var query = GlRepository.GetAll().Where(a =>
                    a.GroupNo == no && a.LogType == LogTypeDefinition.SceneOperation &&
                    a.RoundIndex == group.RoundIndex &&
                    (a.LogState == LogStateDefinition.New || a.LogState == LogStateDefinition.Submit || a.LogState == LogStateDefinition.HasMatch))
                .OrderByDescending(a => a.Id).Select(a => new GroupRoleLogDto()
                {
                    Id = a.Id,
                    GroupNo = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState,
                    ExtendInfo1 = a.ExtendInfo1,
                    ExtendInfo2 = a.ExtendInfo2,
                    ExtendInfo3 = a.ExtendInfo3,
                    ExtendInfo4 = a.ExtendInfo4
                });
            var dtoList = await query.ToListAsync();
            return dtoList;
        }

        /// <summary>
        /// 查询培训营分组的处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<GroupRoleLogDto>> GetGroupLogs(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }
            var query = GlRepository.GetAll().Where(a => a.GroupNo == no && a.LogType == LogTypeDefinition.SceneOperation)
                .OrderByDescending(a => a.Id).Select(a => new GroupRoleLogDto()
                {
                    Id = a.Id,
                    GroupNo = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState
                });
            var dtoList = await query.ToListAsync();
            return dtoList;
        }

        public async Task<List<QueryLogDto>> GetCampLogs(string no)
        {
            var dtoList = await GlRepository.GetAllIncluding(a => a.CampGroupInfo).Where(a => a.CampNo == no && a.LogType == LogTypeDefinition.System)
                .OrderBy(a => a.Id).Select(a => new QueryLogDto()
                {
                    Name = a.CampGroupInfo != null ? a.CampGroupInfo.Name : "系统",
                    Msg = a.LogCommand,
                    Date = a.CreationTime
                }).ToListAsync();

            return dtoList;
        }

        #endregion 日志

        #region 情景

        /// <summary>
        /// 获取分组情景
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<SceneDto>> GetGroupScenes(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }
            List<SceneDto> list = new List<SceneDto>();
            //var pathDto = (ScenePathDto)(await CacheManager.GetCache(IwbCacheNames.SceneInfoCache)
            //    .GetOrDefaultAsync($"SceneNos-{no}"));
            //if (pathDto != null)
            //{
            //    list = (List<SceneDto>)await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetOrDefaultAsync($"SceneInfos-{no}");
            //    if (pathDto.hasChange || list == null || list.Count == 0)
            //    {
            //        pathDto.hasChange = false;
            //        await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneNos-{no}", pathDto);
            //        list = new List<SceneDto>();
            //        foreach (var path in pathDto.PathList)
            //        {
            //            var scene = await GetSceneInfo_Last(no, path);
            //            if (scene != null)
            //            {
            //                list.Add(scene);
            //            }
            //        }
            //        await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneInfos-{no}", list);
            //    }
            //}
            //else
            //{
            //}

            var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
            if (runGroupInfo == null)
            {
                return list;
            }
            var runRounds = runGroupInfo.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
            if (runRounds != null)
                foreach (var r in runRounds)
                {
                    var runBlocks = r.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                    if (runBlocks != null)
                        foreach (var b in runBlocks)
                        {
                            var runFlows = b.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                            if (runFlows != null)
                                foreach (var f in runFlows)
                                {
                                    var runNodes = f.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                                    if (runNodes != null)
                                        foreach (var node in runNodes)
                                        {
                                            list = await GetSceneFromNode(list, node, no);
                                        }
                                }
                        }
                }

            //if (list.Any())
            //{
            //    pathDto = new ScenePathDto()
            //    {
            //        hasChange = false,
            //        PathList = list.Select(a => a.Path).ToList()
            //    };
            //    await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneNos-{no}", pathDto);
            //}

            if (list.Any())
            {
                list = list.OrderByDescending(a => a.HasEnd).ToList();
            }

            return list;
        }

        /// <summary>
        /// 提取情景节点中的情景信息
        /// </summary>
        /// <param name="list"></param>
        /// <param name="node"></param>
        /// <param name="groupNo"></param>
        /// <returns></returns>
        private async Task<List<SceneDto>> GetSceneFromNode(List<SceneDto> list, FlowNodeDataNode node, string groupNo)
        {
            if (node.SceneNodes != null)
            {
                foreach (var scene in node.SceneNodes)
                {
                    var dto = await GetGroupSceneInfo(groupNo, scene.Path);
                    if (dto != null)
                    {
                        dto.HasEnd = scene.IsEnd;
                        list.Add(dto);
                    }
                }
            }
            var child = node.Children?.FirstOrDefault(a => a.IsStart);
            if (child != null)
            {
                list = await GetSceneFromNode(list, child, groupNo);
            }
            return list;
        }

        private async Task<SceneDto> GetSceneInfo_Last(string no, string scenePath)
        {
            var dto = CacheManager.GetCache(IwbCacheNames.SceneInfoCache)
                .Get($"{no}-{scenePath}-end", () => default(SceneDto));
            if (dto == null)
            {
                await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).RemoveAsync($"{no}-{scenePath}");
                dto = await GetGroupSceneInfo(no, scenePath);
            }
            return dto;
        }

        /// <summary>
        /// 查询情景信息
        /// </summary>
        /// <param name="no"></param>
        /// <param name="scenePath"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<SceneDto> GetGroupSceneInfo(string no, string scenePath)
        {
            //Stopwatch stopwatch = new Stopwatch();
            //Stopwatch stopwatch2 = new Stopwatch();
            //stopwatch.Start();
            //stopwatch2.Start();
            var groupCampNo = await GroupRepository.GetAll().Where(a => a.Id == no).Select(a => a.CampNo).FirstOrDefaultAsync();
            if (groupCampNo == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }
            var sceneDto = await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetAsync($"{no}-{scenePath}",
                async () =>
                {
                    SceneDto dto = null;
                    try
                    {
                        var detail = await CacheManager.GetCampPackageDetail(groupCampNo, DataCenterUrl, CampRepository);
                        var scene = detail?.Scenes.FirstOrDefault(a => a.Path == scenePath);
                        if (scene == null)
                        {
                            return null;
                        }
                        dto = scene.Obj2String().Str2Obj<SceneDto>();
                        //var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
                        //if (runGroupInfo == null)
                        //{
                        //    return null;
                        //}
                        //var runScene = runGroupInfo.RunSceneInfos.FirstOrDefault(a => a.Path == scene.Path);
                        //stopwatch.Stop();
                        //this.LogInfo($"1耗时{scenePath}：{stopwatch.ElapsedMilliseconds}毫秒");
                        //stopwatch.Restart();
                        var runScene = await GetRunScene(no, scene);
                        if (runScene != null)
                        {
                            dto.HasEnd = runScene.IsEnd;
                            dto.Variables = dto.Variables.MergeHashtable(runScene.GetVariables());
                        }
                        //stopwatch.Stop();
                        //this.LogInfo($"2耗时{scenePath}：{stopwatch.ElapsedMilliseconds}毫秒");
                        //stopwatch.Restart();
                        var gList = new List<GuideModel>();
                        if (scene.GuideNos.IsNotEmpty())
                        {
                            var arr = scene.GuideNos.Split(',');
                            foreach (var gNo in arr)
                            {
                                var g = detail.Guides?.FirstOrDefault(a => a.Id == gNo);
                                if (g != null)
                                {
                                    gList.Add(g);
                                }
                            }
                        }
                        dto.GuideInfos = gList;
                        var attachList =
                            await CacheManager.GetSceneAttaches(groupCampNo, scene.Id, SceneMapRepository, AttachRepository);
                        dto.Attaches = attachList;
                    }
                    catch (Exception e)
                    {
                        this.LogError(e);
                    }

                    //stopwatch2.Stop();
                    //this.LogInfo($"【总耗时】：{stopwatch2.ElapsedMilliseconds}毫秒");
                    return dto;
                });
            if (sceneDto != null && sceneDto.HasEnd)
            {
                await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"{no}-{scenePath}-end", sceneDto);
            }

            return sceneDto;
        }

        private async Task<SceneDataNode> GetRunScene(string no, SceneModel scene)
        {
            SceneDataNode runScene = null;
            var i = 0;
            while (runScene == null && i < 5)
            {
                var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
                runScene = runGroupInfo?.RunSceneInfos.FirstOrDefault(a => a.Path == scene.Path);
                i++;
                //if (runScene == null)
                //{
                //    await CacheManager.GetCache(IwbCacheNames.GroupRunningInfoCache).RemoveAsync(no);
                //    Thread.Sleep(500 * i);
                //}
                int time = 400 - i * 50;
                time = time > 0 ? time : 50;
                Thread.Sleep(time);
            }

            return runScene;
        }

        #endregion 情景

        /// <summary>
        /// 查询分组当前轮次得分
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<GroupScoreDto> GetGroupScoreInfo(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var score = await GsRepository.GetAll().Where(a => a.GroupNo == no).OrderByDescending(a => a.RoundIndex)
                .FirstOrDefaultAsync();
            if (score == null)
            {
                return null;
            }

            var dto = ObjectMapper.Map<GroupScoreDto>(score);
            return dto;
        }

        /// <summary>
        /// 查询培训营得分
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<QueryGroupScoreDto>> GetScoreInfo(string no)
        {
            var scores = await GsRepository.GetAllIncluding(a => a.CampGroupInfo, a => a.CampGroupInfo.CampInfo)
                .Where(a => a.CampNo == no).OrderBy(a => a.GroupNo).ThenBy(a => a.RoundIndex).Select(a => new QueryGroupScoreDto()
                {
                    GroupNo = a.GroupNo,
                    GroupName = a.CampGroupInfo.Name,
                    CampNo = a.CampNo,
                    RoundIndex = a.RoundIndex,
                    SystemScore = a.FinalTotalScore != 0 ? a.FinalTotalScore : a.SystemScore,
                    TotalScore = a.CampGroupInfo.CampInfo.RoundScore,
                    BehaviorTagScoreInfo = a.BehaviorTagScoreInfo
                }).ToListAsync();

            return scores;
        }

        /// <summary>
        /// 查询培训营得分
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<QueryGroupScoreDto>> GetScoreChart(string no)
        {
            var scores = await GsRepository.GetAllIncluding(a => a.CampGroupInfo, a => a.CampGroupInfo.CampInfo)
                .Where(a => a.CampNo == no).OrderBy(a => a.GroupNo).ThenBy(a => a.RoundIndex).Select(a => new QueryGroupScoreDto()
                {
                    GroupNo = a.GroupNo,
                    GroupName = a.CampGroupInfo.Name,
                    CampNo = a.CampNo,
                    RoundIndex = a.RoundIndex,
                    SystemScore = a.FinalTotalScore > 0 ? a.FinalTotalScore : a.CorrectionScore > 0 ? a.CorrectionScore : a.SystemScore,
                    TotalScore = a.CampGroupInfo.CampInfo.RoundScore,
                    BehaviorTagScoreInfo = a.BehaviorTagScoreInfo
                }).ToListAsync();
            var groups = await GroupRepository.GetAllIncluding(a => a.CampInfo).Where(a => a.CampNo == no).ToListAsync();
            var score = 0;//scores.Any(a => a.SystemScore > 0) ? 0 : 50;
            var btsInfo = "[{\"tagNo\":\"对媒体\",\"systemScore\":0,\"totalScore\":10}," +
                          "{\"tagNo\":\"对上级\",\"systemScore\":0,\"totalScore\":10}," +
                          "{\"tagNo\":\"对下级\",\"systemScore\":0,\"totalScore\":10}," +
                          "{\"tagNo\":\"对相关单位\",\"systemScore\":0,\"totalScore\":10}," +
                          "{\"tagNo\":\"决策力\",\"systemScore\":8,\"totalScore\":10}," +
                          "{\"tagNo\":\"协调力\",\"systemScore\":8,\"totalScore\":10}," +
                          "{\"tagNo\":\"研判力\",\"systemScore\":8,\"totalScore\":10}," +
                          "{\"tagNo\":\"舆论引导力\",\"systemScore\":8,\"totalScore\":10}," +
                          "{\"tagNo\":\"掌控力\",\"systemScore\":8,\"totalScore\":10}]";
            foreach (var group in groups)
            {
                for (int i = 1; i <= 3; i++)
                {
                    //if (!scores.Any(a => a.GroupNo == group.Id && a.RoundIndex == group.RoundIndex))
                    var scoreDto = scores.FirstOrDefault(a => a.GroupNo == group.Id && a.RoundIndex == i);
                    if (scoreDto == null)
                    {
                        scores.Add(new QueryGroupScoreDto()
                        {
                            GroupNo = group.Id,
                            GroupName = group.Name,
                            CampNo = group.CampNo,
                            RoundIndex = i,
                            SystemScore = score,
                            TotalScore = group.CampInfo.RoundScore,
                            BehaviorTagScoreInfo = btsInfo
                        });
                    }
                    else
                    {
                        if (scoreDto.BehaviorTagScoreInfo.IsEmpty())
                        {
                            scoreDto.BehaviorTagScoreInfo = btsInfo;
                        }
                    }
                }
            }

            return scores.OrderBy(a => a.GroupNo).ToList();
        }

        /// <summary>
        /// 查询培训营处理日志统计
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<ChartLogDto>> GetCampLogChart(string no)
        {
            var list = await GlRepository.GetAllIncluding(a => a.CampGroupInfo)
                .Where(a => a.CampNo == no && a.LogType == LogTypeDefinition.SceneOperation).Select(a => new GroupRoleLogDto
                {
                    GroupNo = a.GroupNo,
                    GroupName = a.CampGroupInfo.Name,
                    LogState = a.LogState,
                }).ToListAsync();

            var dtoList = list.GroupBy(a => a.GroupNo).Select(a => new ChartLogDto()
            {
                GroupNo = a.Key,
                GroupName = a.FirstOrDefault()?.GroupName,
                Matched = a.Count(s => s.LogState == LogStateDefinition.HasMatch || s.LogState == LogStateDefinition.HasSendMatch),
                NotMatched = a.Count(s => s.LogState == LogStateDefinition.Send || s.LogState == LogStateDefinition.Submit)
            }).ToList();
            var groups = await GroupRepository.GetAllListAsync((a => a.CampNo == no));
            foreach (var group in groups)
            {
                if (dtoList.All(a => a.GroupNo != group.Id))
                {
                    dtoList.Add(new ChartLogDto()
                    {
                        GroupNo = group.Id,
                        GroupName = group.Name,
                        Matched = 0,
                        NotMatched = 0,
                    });
                }
            }
            return dtoList.OrderBy(a => a.GroupNo).ToList();
        }

        public async Task<StepList.StepInfo> GetCampStep(string no)
        {
            var log = await GlRepository.GetAll()
                .Where(a => a.CampNo == no && a.LogCommand == LogCommandDefinition.Step)
                .OrderByDescending(a => a.CreationTime).FirstOrDefaultAsync();
            var dto = log?.LogMessage.Str2Obj<StepList.StepInfo>();
            return dto;
        }

        public async Task<string> Voice(string txt, int? rate = null, int? vol = null)
        {
            string fileName = $"{DateTime.Now:yyyyMMddHHmmssfff}.wav",
                filePath =
                    $"/{await SettingManager.GetSettingValueAsync(IwbSettingNames.DownloadPath)}/Voice",
                fullPath = $"{AppDomain.CurrentDomain.BaseDirectory}/{filePath}";
            if (!Directory.Exists(fullPath))
            {
                Directory.CreateDirectory(fullPath);
            }

            var task = Task.Run(() =>
            {
                using (var sp = new SpeechSynthesizer())
                using (MemoryStream ms = new MemoryStream())
                {
                    sp.Rate = rate ?? 0;
                    sp.Volume = vol ?? 90;
                    //sp.SetOutputToWaveStream(ms);
                    sp.SetOutputToWaveFile($"{fullPath}/{fileName}");
                    Prompt prompt = new Prompt(txt);
                    sp.Speak(prompt);
                    ms.Position = 0;
                }
            });
            Task.WaitAll(task);
            return $"{filePath}/{fileName}";
        }
    }
}