App_V2.3/SourceCode/WeApp.Application/TrainingPortrait/PortraitAppService.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Mvc;

using Abp.Auditing;
using Abp.Authorization;
using Abp.Configuration;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;

using IwbZero.Auditing;
using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;

using WeApp.Authorization;
using WeApp.BaseSystem.Query;
using WeApp.Configuration;
using WeApp.Configuration.Cache;
using WeApp.TrainingCamp;
using WeApp.TrainingPortrait.Dto;

using WeEngine.CommonDto;
using WeEngine.CommonDto.PortraitDto;
using WeEngine.CommonDto.ReportDto;
using WeEngine.Packages;

namespace WeApp.TrainingPortrait
{
    [AbpAuthorize, AuditLog("演练培训营画像")]
    public class PortraitAppService : IwbAppServiceBase, IPortraitAppService
    {
        public PortraitAppService(IRepository<CampInfo, string> campRepository, ICacheManager cacheManager, IRepository<CampGroupInfo, string> groupRepository, IRepository<GroupPortraitInfo> portraitRepository, IRepository<GroupLogInfo> glRepository, IRepository<GroupScoreInfo> gsRepository, QueryAppService queryApp)
        {
            CampRepository = campRepository;
            GroupRepository = groupRepository;
            PortraitRepository = portraitRepository;
            GlRepository = glRepository;
            GsRepository = gsRepository;
            QueryApp = queryApp;
            CacheManager = cacheManager;
        }

        private string DataCenterUrl => IwbSettingNames.GetWeDataCenterIp(SettingManager).Ew("/");
        protected IRepository<CampInfo, string> CampRepository { get; }
        protected IRepository<CampGroupInfo, string> GroupRepository { get; }
        protected IRepository<GroupPortraitInfo> PortraitRepository { get; }
        protected IRepository<GroupLogInfo> GlRepository { get; }
        protected IRepository<GroupScoreInfo> GsRepository { get; }
        protected QueryAppService QueryApp { get; }

        /// <summary>
        /// 更新画像说明
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task UpdateRemark(UpdateRemarkDto input)
        {
            var entity = await PortraitRepository.GetAllIncluding(a => a.GroupInfo, a => a.GroupInfo.CampInfo)
                .FirstOrDefaultAsync(a => a.GroupNo == input.GroupNo);
            if (entity == null)
            {
                CheckErrors("演练画像还未生成！");
                return;
            }

            switch (input.Type)
            {
                case PortraitRemarkTypeDefinition.Scene:
                    entity.SceneRemark = input.Remark;
                    break;

                case PortraitRemarkTypeDefinition.SiGong:
                    entity.SiGongRemark = input.Remark;
                    break;

                case PortraitRemarkTypeDefinition.WuLi:
                    entity.WuLiRemark = input.Remark;
                    break;

                case PortraitRemarkTypeDefinition.Short:
                    entity.ShortRemark = input.Remark;
                    break;

                case PortraitRemarkTypeDefinition.ZhuanJia:
                    entity.ZhuanJiaRemark = input.Remark;
                    break;
            }

            await PortraitRepository.UpdateAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
            //更新缓存
            var dto = await GenerateGroupPortrait(input.GroupNo);
            if (dto != null)
            {
                switch (input.Type)
                {
                    case PortraitRemarkTypeDefinition.Scene:
                        dto.SceneRemark = input.Remark;
                        break;

                    case PortraitRemarkTypeDefinition.SiGong:
                        dto.SiGongRemark = input.Remark;
                        break;

                    case PortraitRemarkTypeDefinition.WuLi:
                        dto.WuLiRemark = input.Remark;
                        break;

                    case PortraitRemarkTypeDefinition.Short:
                        dto.ShortRemark = input.Remark;
                        break;

                    case PortraitRemarkTypeDefinition.ZhuanJia:
                        dto.ZhuanJiaRemark = input.Remark;
                        break;
                }
            }
            await CacheManager.GetCache(IwbCacheNames.CampPortraitInfoCache).SetAsync($"GP-{input.GroupNo}", dto);
        }

        /// <summary>
        /// 重新生成培训营画像
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgPortraitMgGenerate), AuditLog("重新生成画像")]
        public async Task CleanPortrait(string no)
        {
            var groups = await GroupRepository.GetAllListAsync(a => a.CampNo == no);
            foreach (var g in groups)
            {
                await CacheManager.GetCache(IwbCacheNames.CampPortraitInfoCache).RemoveAsync($"GP-{g.Id}");
                await CacheManager.GetCache(IwbCacheNames.CampPortraitInfoCache).RemoveAsync($"GR-{g.Id}");
                await CacheManager.GetCache(IwbCacheNames.CampPortraitInfoCache).RemoveAsync($"GT-{g.Id}");
            }
        }

        /// <summary>
        /// 生成分组画像
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgPortraitMgGenerate), AuditLog("生成画像")]
        public async Task<GroupPortraitDto> GenerateGroupPortrait(string no)
        {
            var group = await GroupRepository.GetAllIncluding(a => a.CampInfo)
                .FirstOrDefaultAsync(a => a.Id == no);
            return await GenerateGroupPortrait(group);
        }

        /// <summary>
        /// 查询演练报告基础信息
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<GroupReportDto> GetGroupReportBase(string no)
        {
            var dto = await GroupRepository.GetAllIncluding(a => a.CampInfo).Where(a => a.Id == no).Select(a =>
                new GroupReportDto()
                {
                    Id = a.Id,
                    Name = a.Name,
                    CampNo = a.CampNo,
                    CampName = a.CampInfo.Name,
                    PackageName = a.CampInfo.PackageName,
                    StartDate = a.StartDate,
                    EndDate = a.EngDate,
                    TrainingMinute = a.TrainingMinute,
                }).FirstOrDefaultAsync();
            if (dto != null)
            {
                var roles = await QueryApp.GetGroupRoleInfos(no);
                dto.RoleNames = string.Join(",", roles);
            }
            return dto;
        }

        /// <summary>
        /// 查询演练数据
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing, AllowAnonymous, AbpAllowAnonymous]
        public async Task<GroupReportDto> GetGroupReportData(string no)
        {
            var entity = await PortraitRepository.GetAllIncluding(a => a.GroupInfo, a => a.GroupInfo.CampInfo)
                .FirstOrDefaultAsync(a => a.GroupNo == no);
            var group = entity?.GroupInfo;
            if (entity == null || group == null)
            {
                return null;
            }

            return await CacheManager.GetCache(IwbCacheNames.CampPortraitInfoCache).GetAsync($"GR-{no}", async () =>
            {
                var dto = new GroupReportDto();
                var runningInfo = group.RunningInfo?.Str2Obj<PackageDataNode>();
                dto.EvalQualitativeResult = runningInfo?.EvalQualitativeResult;
                dto.ChartData = TrainingInfoFrom(runningInfo, no);
                var groupScores = await GsRepository.GetAllListAsync(a => a.GroupNo == no);
                dto.Scenes = await ReportRoundSceneDtoFrom(runningInfo, no, groupScores);
                dto.ScoreData = await RoundScoreDtoFrom(groupScores);
                dto.ReportEvalStrings = new List<ReportEvalString>()
                {
                   // new ReportEvalString(PortraitRemarkTypeDefinition.Scene,entity.SceneRemark),
                    new ReportEvalString(PortraitRemarkTypeDefinition.SiGong,entity.SiGongRemark),
                    new ReportEvalString(PortraitRemarkTypeDefinition.WuLi,entity.WuLiRemark),
                    new ReportEvalString(PortraitRemarkTypeDefinition.Short,entity.ShortRemark),
                    new ReportEvalString(PortraitRemarkTypeDefinition.ZhuanJia,entity.ZhuanJiaRemark),
                };

                return dto;
            });
        }

        /// <summary>
        /// 生成分组画像
        /// </summary>
        /// <param name="group"></param>
        /// <returns></returns>
        private async Task<GroupPortraitDto> GenerateGroupPortrait(CampGroupInfo group)
        {
            return await CacheManager.GetCache(IwbCacheNames.CampPortraitInfoCache).GetAsync($"GP-{group.Id}", async () =>
            {
                try
                {
                    var entity = await PortraitRepository.GetAllIncluding(a => a.GroupInfo, a => a.GroupInfo.CampInfo)
                    .FirstOrDefaultAsync(a => a.GroupNo == group.Id);
                    if (entity == null)
                    {
                        entity = new GroupPortraitInfo()
                        {
                            GroupNo = group.Id,
                            CampNo = group.CampNo,
                        };
                    }
                    var roleLogs = await GlRepository.GetAllListAsync(a =>
                        a.GroupNo == group.Id && a.LogType == LogTypeDefinition.SceneOperation &&
                        (a.LogState == LogStateDefinition.NotSend || a.LogState == LogStateDefinition.Send || a.LogState == LogStateDefinition.HasSendMatch));
                    entity.CmdCount = roleLogs.Count;
                    entity.RoleCount = roleLogs.GroupBy(a => a.RoleName).Count();
                    entity.RoleCmdInfos = RoundRoleCmdDtoFrom(roleLogs).Obj2StringCamelCase();
                    PackageDataNode runNode = group.RunningInfo?.Str2Obj<PackageDataNode>();
                    //if (group.RunningInfo.Contains("PackageNo"))
                    //{
                    //    var str = group.RunningInfo?
                    //        .Replace("\"PackageNo\"", "\"p\"")
                    //        .Replace("\"Children\"", "\"ch\"")
                    //        .Replace("\"Id\"", "\"i\"")
                    //        .Replace("\"No\"", "\"n\"")
                    //        .Replace("\"Name\"", "\"nm\"")
                    //        .Replace("\"Path\"", "\"p\"")
                    //        .Replace("\"Variables\"", "\"v\"")
                    //        .Replace("\"FullScore\"", "\"fs\"")
                    //        .Replace("\"CorrectionScore\"", "\"cs\"")
                    //        .Replace("\"SystemScore\"", "\"ss\"")
                    //        .Replace("\"IsStart\"", "\"r\"")
                    //        .Replace("\"IsEnd\"", "\"re\"")
                    //        .Replace("\"WaitPath\"", "\"W\"")
                    //        .Replace("\"CurrentRoundIndex\"", "\"cri\"")
                    //        .Replace("\"AssessRoles\"", "\"ar\"")
                    //        .Replace("\"AssessAuto\"", "\"aa\"")
                    //        .Replace("\"AutoNextRound\"", "\"anr\"")
                    //        .Replace("\"RoundScore\"", "\"rs\"")
                    //        .Replace("\"EvalQualitativeResult\"", "\"eqr\"")
                    //        .Replace("\"RoundIndex\"", "\"ri\"")
                    //        .Replace("\"BlockType\"", "\"bt\"")
                    //        .Replace("\"SceneNodes\"", "\"sn\"")
                    //        .Replace("\"BehaviorTagString\"", "\"bts\"")
                    //        .Replace("\"BehaviorTag\"", "\"bt\"")
                    //        .Replace("\"Keywords\"", "\"k\"");
                    //    runNode = str.Str2Obj<PackageDataNode>();
                    //}

                    var runningInfo = GetFullRunningInfo(runNode);
                    entity.TrainingInfos = TrainingInfoFrom(runningInfo, group.Id).Obj2StringCamelCase();
                    var roundScenes = await RoundSceneDtoFrom(runningInfo, group.Id);
                    entity.SceneCount = roundScenes.Sum(a => a.SceneInfos.Count);
                    entity.SceneInfos = roundScenes.Obj2StringCamelCase();
                    var groupScores = await GsRepository.GetAllListAsync(a => a.GroupNo == group.Id);
                    var roundScore = await RoundScoreDtoFrom(groupScores);
                    entity.RoundScoreInfos = roundScore.ScoreInfos.Obj2StringCamelCase();
                    entity.SiGongInfos = roundScore.SiGongInfos.Obj2StringCamelCase();
                    entity.WuLiInfos = roundScore.WuLiInfos.Obj2StringCamelCase();
                    await PortraitRepository.InsertOrUpdateAsync(entity);
                    await CurrentUnitOfWork.SaveChangesAsync();
                    return ObjectMapper.Map<GroupPortraitDto>(entity);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    return null;
                }
            });
        }

        private PackageDataNode GetFullRunningInfo(PackageDataNode runningNode)
        {
            return CacheManager.GetCache(IwbCacheNames.CampPortraitInfoCache).Get($"RN_{runningNode.Id}", () =>
            {
                var pn = CacheManager.GetPackageDataNode(runningNode.PackageNo, DataCenterUrl);
                if (pn != null)
                {
                    runningNode.MergeNode(pn);
                }

                return runningNode;
            });
        }

        private List<RoundRoleCmdDto> RoundRoleCmdDtoFrom(List<GroupLogInfo> logs)
        {
            var list = new List<RoundRoleCmdDto>();
            var roundLogs = logs.GroupBy(a => a.RoundIndex);
            foreach (var roundLog in roundLogs)
            {
                var roundIndex = roundLog.Key;
                var cmd = new RoundRoleCmdDto()
                {
                    RoundIndex = roundIndex,
                    RoleCmdInfos = RoleCmdDtoFrom(logs.Where(a => a.RoundIndex == roundIndex).ToList())
                };
                list.Add(cmd);
            }
            return list;
        }

        private List<RoleCmdDto> RoleCmdDtoFrom(List<GroupLogInfo> logs)
        {
            var list = new List<RoleCmdDto>();

            var roleLogs = logs.GroupBy(a => a.RoleName);
            foreach (var roleLog in roleLogs)
            {
                var roleName = roleLog.Key;
                var roleLogList = logs.Where(a => a.RoleName == roleName).ToList();
                var log = new RoleCmdDto()
                {
                    RoleName = roleName,
                    CmdInfo = new List<string>()
                };
                foreach (var l in roleLogList)
                {
                    log.CmdInfo.Add($"{l.LogState}|{l.LogMessage}");
                }
                list.Add(log);
            }
            return list;
        }

        private async Task<List<RoundSceneDto>> RoundSceneDtoFrom(PackageDataNode runningInfo, string groupNo)
        {
            var list = new List<RoundSceneDto>();
            var roundInfos = runningInfo?.RunRoundInfos;
            if (roundInfos != null)
            {
                foreach (var roundInfo in roundInfos)
                {
                    var roundScene = new RoundSceneDto() { RoundIndex = roundInfo.RoundIndex, SceneInfos = new List<SceneDto>() };
                    if (roundInfo.RunSceneInfos != null)
                    {
                        foreach (var info in roundInfo.RunSceneInfos)
                        {
                            var scene = await QueryApp.GetGroupSceneInfo(groupNo, info.Path);
                            roundScene.SceneInfos.Add(scene);
                        }
                    }
                    list.Add(roundScene);
                }
            }
            return list;
        }

        private async Task<RoundScoreDto> RoundScoreDtoFrom(List<GroupScoreInfo> scoreInfos)
        {
            scoreInfos = scoreInfos.OrderBy(a => a.RoundIndex).ToList();
            var roundScore = new RoundScoreDto()
            {
                ScoreInfos = new List<decimal>(),
                SiGongInfos = new List<TagScoreDto>(),
                WuLiInfos = new List<TagScoreDto>()
            };
            var tags = await SettingManager.GetSettingValueAsync(IwbSettingNames.SiGongWuLiTag);
            var arr = tags.Split('|');
            if (arr.Length < 2)
            {
                return null;
            }

            var sgTagArr = arr[0].Split(',');
            var wlTagArr = arr[1].Split(',');
            foreach (var s in sgTagArr)
            {
                roundScore.SiGongInfos.Add(new TagScoreDto() { Name = s, TagScoreInfos = new List<decimal>() });
            }
            foreach (var s in wlTagArr)
            {
                roundScore.WuLiInfos.Add(new TagScoreDto() { Name = s, TagScoreInfos = new List<decimal>() });
            }
            foreach (var info in scoreInfos)
            {
                roundScore.ScoreInfos.Add(info.FinalTotalScore == 0 ? info.SystemScore : info.FinalTotalScore);
                var tagScores = info.BehaviorTagScoreInfo.Str2Obj<List<TagScoreInfo>>();
                foreach (var scoreInfo in tagScores)
                {
                    var sg = roundScore.SiGongInfos.FirstOrDefault(a => a.Name == scoreInfo.TagNo);
                    if (sg != null)
                    {
                        var score = scoreInfo.TotalScore == 0
                            ? 0
                            : (scoreInfo.CorrectionScore == 0
                                ? scoreInfo.SystemScore
                                : scoreInfo.CorrectionScore) * 100 / scoreInfo.TotalScore;
                        score = Math.Round(score > 100 ? 100 : score, 2);
                        sg.TagScoreInfos.Add(score);
                    }
                    var wl = roundScore.WuLiInfos.FirstOrDefault(a => a.Name == scoreInfo.TagNo);
                    if (wl != null)
                    {
                        var score = scoreInfo.TotalScore == 0
                            ? 0
                            : (scoreInfo.CorrectionScore == 0
                                  ? scoreInfo.SystemScore
                                  : scoreInfo.CorrectionScore) * 100 / scoreInfo.TotalScore;
                        score = Math.Round(score > 100 ? 100 : score, 2);
                        wl.TagScoreInfos.Add(score);
                    }
                }
            }

            return roundScore;
        }

        private List<TrainingRoundInfoDto> TrainingInfoFrom(PackageDataNode runningInfo, string groupNo)
        {
            return CacheManager.GetCache(IwbCacheNames.CampPortraitInfoCache).Get($"GT-{groupNo}", () =>
          {
              var dtoList = new List<TrainingRoundInfoDto>();
              var roundInfos = runningInfo?.RunRoundInfos;
              if (roundInfos != null)
              {
                  foreach (var r in roundInfos)
                  {
                      var roundInfo = new TrainingRoundInfoDto(r.RoundIndex);
                      var rt = new TrainingInfoDto($"第{r.RoundIndex}轮", r.Id, r.IsStart);
                      foreach (var b in r.Children)
                      {
                          //var bt = new TrainingInfoDto($"情景块[{b.Path}]", b.Path,b.IsStart);
                          foreach (var f in b.Children)
                          {
                              var ft = new TrainingInfoDto($"情景流[{f.Name}]", f.Id, f.IsStart);
                              ft.Children.AddRange(TrainingInfoNodeFrom(f.Children) ?? new List<TrainingInfoDto>());
                              rt.Children.Add(ft);
                          }

                          //rt.Children.Add(bt);
                      }
                      var flows = r.RunFlowInfos;
                      foreach (var f2 in flows)
                      {
                          var fcFlow = FcFlowInfoFrom(f2.Children, new FcFlowInfoDto(f2.Name));
                          roundInfo.AddFcFlowInfo(fcFlow);
                      }
                      roundInfo.Infos.Add(rt);
                      dtoList.Add(roundInfo);
                  }
              }
              return dtoList;
          });
        }

        private List<TrainingInfoDto> TrainingInfoNodeFrom(List<FlowNodeDataNode> nodes, int i = 0)
        {
            i++;
            var dtoList = new List<TrainingInfoDto>();
            if (nodes != null && nodes.Any())
            {
                foreach (var node in nodes)
                {
                    var name = string.Join(",", node.SceneNodes.Select(a => a.Name).ToArray());
                    var nt = new TrainingInfoDto($"情景{i}:{name}", node.Id, node.IsStart);
                    if (node.Children != null && node.Children.Any())
                    {
                        nt.Children.AddRange(TrainingInfoNodeFrom(node.Children, i));
                    }
                    dtoList.Add(nt);
                }
            }

            return dtoList;
        }

        private FcFlowInfoDto FcFlowInfoFrom(List<FlowNodeDataNode> infos, FcFlowInfoDto fcFlow)
        {
            infos = infos.Where(a => a.IsStart).ToList();
            foreach (var info in infos)
            {
                var scenes = info.SceneNodes.Where(a => a.IsStart).ToList();
                foreach (var s in scenes)
                {
                    fcFlow.FlowInfos.Add(new PointDto(s.Name));
                }

                if (info.Children != null && info.Children.Any())
                {
                    fcFlow = FcFlowInfoFrom(info.Children, fcFlow);
                }
            }
            return fcFlow;
        }

        private async Task<List<ReportRoundSceneDto>> ReportRoundSceneDtoFrom(PackageDataNode runningInfo, string groupNo, List<GroupScoreInfo> scoreInfos)
        {
            var list = new List<ReportRoundSceneDto>();
            var roundInfos = runningInfo?.Children;
            if (roundInfos != null)
            {
                foreach (var roundInfo in roundInfos)
                {
                    var roundScene = new ReportRoundSceneDto() { RoundIndex = roundInfo.RoundIndex, SceneInfos = new List<ReportSceneDto>() };
                    if (roundInfo.RunSceneInfos != null)
                    {
                        foreach (var info in roundInfo.RunSceneInfos)
                        {
                            var scene = await GetGroupSceneInfoWithBehavior(groupNo, info.Id);
                            roundScene.SceneInfos.Add(scene);
                        }
                    }

                    var bTagList = new List<ReportBehaviorTagDto>();
                    var scoreInfo = scoreInfos.FirstOrDefault(a => a.RoundIndex == roundInfo.RoundIndex);
                    var tagScores = scoreInfo?.BehaviorTagScoreInfo.Str2Obj<List<TagScoreInfo>>();
                    if (tagScores != null)
                    {
                        var tags = await SettingManager.GetSettingValueAsync(IwbSettingNames.SiGongWuLiTag);
                        var setting = await SettingManager.GetSettingValueAsync(IwbSettingNames.ReportTagLevel);
                        var arr = tags.Split('|');
                        if (arr.Length < 2)
                        {
                            return null;
                        }
                        var sgTagArr = arr[0].Split(',');
                        var wlTagArr = arr[1].Split(',');
                        foreach (var s in sgTagArr)
                        {
                            var t = tagScores.FirstOrDefault(a => a.TagNo == s);
                            bTagList.Add(t == null || t.TotalScore == 0
                                ? new ReportBehaviorTagDto(s)
                                : new ReportBehaviorTagDto(t, setting));
                        }
                        foreach (var s in wlTagArr)
                        {
                            var t = tagScores.FirstOrDefault(a => a.TagNo == s);
                            bTagList.Add(t == null || t.TotalScore == 0 ? new ReportBehaviorTagDto(s) : new ReportBehaviorTagDto(t, setting));
                        }
                    }
                    roundScene.BehaviorTags = bTagList;
                    list.Add(roundScene);
                }
            }
            return list;
        }

        private async Task<ReportSceneDto> GetGroupSceneInfoWithBehavior(string no, string sceneNo)
        {
            var playInfo = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (playInfo == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }
            try
            {
                var detail = await CacheManager.GetCampPackageDetail(playInfo.CampNo, DataCenterUrl, CampRepository);
                var scene = detail?.Scenes.FirstOrDefault(a => a.Id == sceneNo);
                if (scene == null)
                {
                    return null;
                }
                var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
                if (runGroupInfo == null)
                {
                    return null;
                }
                //var dto = ObjectMapper.Map<SceneDto>(scene);
                var runScene = runGroupInfo.RunSceneInfos.FirstOrDefault(a => a.Path == scene.Path);
                if (runScene != null)
                {
                    //dto.HasEnd = runScene.IsEnd;
                    scene.Variables = scene.Variables.MergeHashtable(runScene.GetVariables());
                    //dto.Variables = scene.Variables;
                }
                var bList = new List<BehaviorDto>();
                if (scene.BehaviorNos.IsNotEmpty())
                {
                    var arr = scene.BehaviorNos.Split(',');
                    foreach (var s in arr)
                    {
                        var b = detail.Behaviors?.FirstOrDefault(a => a.Id == s);
                        if (b != null)
                        {
                            var behavior = runGroupInfo.RunBehaviorInfos?.FirstOrDefault(a => a.Path == b.Path);
                            if (behavior != null)
                            {
                                var bDto = new BehaviorDto(behavior)
                                {
                                    Description = b.Description
                                };
                                bList.Add(bDto);
                            }
                        }
                    }
                }

                var bTagList = new List<ReportBehaviorTagDto>();
                if (runScene?.BehaviorTagPer.Count > 0)
                {
                    var tags = await SettingManager.GetSettingValueAsync(IwbSettingNames.SiGongWuLiTag);
                    var setting = await SettingManager.GetSettingValueAsync(IwbSettingNames.ReportTagLevel);
                    var arr = tags.Split('|');
                    if (arr.Length < 2)
                    {
                        return null;
                    }
                    var sgTagArr = arr[0].Split(',');
                    var wlTagArr = arr[1].Split(',');
                    foreach (var s in sgTagArr)
                    {
                        var t = runScene.BehaviorTagPer.FirstOrDefault(a => a.TagNo == s);
                        bTagList.Add(t == null ? new ReportBehaviorTagDto(s) : new ReportBehaviorTagDto(t, setting));
                    }
                    foreach (var s in wlTagArr)
                    {
                        var t = runScene.BehaviorTagPer.FirstOrDefault(a => a.TagNo == s);
                        bTagList.Add(t == null ? new ReportBehaviorTagDto(s) : new ReportBehaviorTagDto(t, setting));
                    }
                }
                var rDto = new ReportSceneDto(scene)
                {
                    Behaviors = bList,
                    BehaviorTags = bTagList
                };
                return rDto;
            }
            catch (Exception e)
            {
                this.LogError(e);
            }
            return null;
        }
    }
}