App_V2.3/SourceCode/WeApp.Core/Configuration/Cache/CacheMangerEx.cs

using Abp.Domain.Repositories;
using Abp.Runtime.Caching;

using IwbZero.ToolCommon;
using IwbZero.ToolCommon.StringModel;

using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;

using WeApp.BaseInfo;
using WeApp.TrainingCamp;

using WeEngine.CommonDto;
using WeEngine.CommonDto.WeInfo;
using WeEngine.Packages;

namespace WeApp.Configuration.Cache
{
    public static class CacheMangerEx
    {
        /// <summary>
        /// 方案包详情
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="no"></param>
        /// <param name="urlPrev"></param>
        /// <returns></returns>
        public static WePackageDetailDto GetPackageDetail(this ICacheManager CacheManager, string no, string urlPrev)
        {
            return CacheManager.GetCache(IwbCacheNames.PackageInfoCache).Get($"PD{no}", () =>
          {
              var url = $"{urlPrev.Ew("/")}api/services/WePlatform/WePackage/GetPackageDetail?no={no}";
              var result = url.RequestPost("");
              var dto = result.Str2Obj<WePackageDetailDto>();
              return dto;
          });
        }

        /// <summary>
        /// 培训营方案包详情
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="no"></param>
        /// <param name="urlPrev"></param>
        /// <param name="rep"></param>
        /// <returns></returns>
        public static async Task<WePackageDetailDto> GetCampPackageDetail(this ICacheManager CacheManager, string no, string urlPrev, IRepository<CampInfo, string> rep)
        {
            return await CacheManager.GetCache(IwbCacheNames.PackageInfoCache).GetAsync($"CPD{no}", async () =>
          {
              var camp = await rep.FirstOrDefaultAsync(a => a.Id == no);
              if (camp == null)
              {
                  return null;
              }
              var dto = GetPackageDetail(CacheManager, camp.PackageNo, urlPrev);
              return dto;
          });
        }

        /// <summary>
        /// 方案包信息
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="no"></param>
        /// <param name="urlPrev"></param>
        /// <returns></returns>
        public static WePackageDto GetPackageInfo(this ICacheManager CacheManager, string no, string urlPrev)
        {
            return CacheManager.GetCache(IwbCacheNames.PackageInfoCache).Get($"PI{no}", () =>
          {
              var url =
                  $"{urlPrev.Ew("/")}api/services/WePlatform/WePackage/GetPackageInfo?no={no}";
              var result = url.RequestPost("");
              var dto = result.Str2Obj<WePackageDto>();
              return dto;
          });
        }

        /// <summary>
        /// 获取全部方案包
        /// </summary>
        /// <returns></returns>
        public static List<WePackageDto> GetPackageInfos(this ICacheManager CacheManager, string urlPrev)
        {
            var url =
                $"{urlPrev.Ew("/")}api/services/WePlatform/WePackage/GetPackageInfos";
            var result = url.RequestPost("");
            var list = result.Str2Obj<List<WePackageDto>>();
            return list;
            //CacheManager.GetCache(IwbCacheNames.PackageInfoCache).Remove("ALL");
            //return  CacheManager.GetCache(IwbCacheNames.PackageInfoCache).Get("ALL",  () =>
            //{
            //    var url =
            //        $"{urlPrev.Ew("/")}api/services/WePlatform/WePackage/GetPackageInfos";
            //    var result = url.RequestPost("");
            //    var list = result.Str2Obj<List<WePackageDto>>();
            //    return list;
            //});
        }

        /// <summary>
        /// 获取方案包xml
        /// </summary>
        /// <returns></returns>
        public static WePackageXmlDto GetPackageXmlInfos(this ICacheManager CacheManager, string no, string urlPrev)
        {
            return CacheManager.GetCache(IwbCacheNames.PackageInfoCache).Get($"XML{no}", () =>
          {
              var url =
                  $"{urlPrev.Ew("/")}api/services/WePlatform/WePackage/GetPackageXml?no={no}";
              var result = url.RequestPost("");
              var xml = result.Str2Obj<WePackageXmlDto>();
              return xml;
          });
        }

        public static PackageNode GetPackageNode(this ICacheManager CacheManager, string no, string urlPrev)
        {
            return CacheManager.GetCache(IwbCacheNames.PackageInfoCache).Get($"XML_NODE{no}", () =>
            {
                var pXml = GetPackageXmlInfos(CacheManager, no, urlPrev);
                var pn = pXml.ToPackage();
                return pn;
            });
        }

        public static PackageDataNode GetPackageDataNode(this ICacheManager CacheManager, string no, string urlPrev)
        {
            return CacheManager.GetCache(IwbCacheNames.PackageInfoCache).Get($"XML_DATA_NODE{no}", () =>
            {
                var pXml = GetPackageXmlInfos(CacheManager, no, urlPrev);
                var pn = pXml.ToDataNode();
                return pn;
            });
        }

        /// <summary>
        /// 获取消息客户端信息
        /// </summary>
        /// <returns></returns>
        public static MsgClientDto GetMsgClientDto(this ICacheManager CacheManager, string appid, string urlPrev)
        {
            return CacheManager.GetCache("WeAppClient").Get($"{appid}", () =>
          {
              var url =
                  $"{urlPrev.Ew("/")}api/services/WePlatform/MessageServer/GetClient?appid={appid}";
              var result = url.RequestPost("");
              var list = result.Str2Obj<MsgClientDto>();
              return list;
          });
        }

        /// <summary>
        /// 获取培训营行为标签
        /// </summary>
        /// <returns></returns>
        public static async Task<GroupScoreInfo> GetGroupRoundScore(this ICacheManager CacheManager, string no, int round, IRepository<GroupScoreInfo> rep)
        {
            return await CacheManager.GetCache(IwbCacheNames.GroupRunningInfoCache).GetAsync($"SCORE-{no}-{round}", async () =>
               {
                   var gs = await rep.GetAllIncluding(a => a.CampGroupInfo).FirstOrDefaultAsync(a => a.GroupNo == no && a.RoundIndex == round);
                   return gs;
               });
        }

        /// <summary>
        /// 获取培训营行为标签
        /// </summary>
        /// <returns></returns>
        public static async Task<List<string>> GetCampTags(this ICacheManager CacheManager, string no, IRepository<CampInfo, string> rep)
        {
            return await CacheManager.GetCache(IwbCacheNames.CampInfoCache).Get($"TAG{no}", async () =>
           {
               var camp = await rep.FirstOrDefaultAsync(a => a.Id == no);
               if (camp == null || camp.EvalBehaviorTags.IsEmpty())
               {
                   return null;
               }

               var list = camp.EvalBehaviorTags.Split(',').ToList();
               return list;
           });
        }

        /// <summary>
        /// 获取分组运行信息
        /// </summary>
        /// <returns></returns>
        public static async Task<PackageDataNode> GetGroupRunningInfo(this ICacheManager CacheManager, string no, IRepository<CampGroupInfo, string> rep)
        {
            var runGroupInfo = await CacheManager.GetCache(IwbCacheNames.GroupRunningInfoCache)
                .GetAsync(no, async () =>
                {
                    var entity = await rep.GetAllIncluding(a => a.CampInfo)
                        .FirstOrDefaultAsync(a => a.Id == no);
                    if (entity == null)
                    {
                        return null;
                    }
                    PackageDataNode info = null;
                    if (entity.RunningInfo.IsNotEmpty())
                    {
                        info = entity.RunningInfo.Str2Obj<PackageDataNode>();
                        info.Name = entity.Name;
                    }
                    return info;
                });
            return runGroupInfo;
        }

        /// <summary>
        /// 获取情景附件
        /// </summary>
        /// <returns></returns>
        public static async Task<List<CampAttachDto>> GetSceneAttaches(this ICacheManager CacheManager, string campNo, string no, IRepository<CampSceneMapInfo> rep, IRepository<SysAttachFile> rep2)
        {
            return await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).Get($"A-{campNo}-{no}", async () =>
            {
                var sceneMap = await rep.FirstOrDefaultAsync(a => a.CampNo == campNo && a.SceneNo == no);
                if (sceneMap == null)
                {
                    return null;
                }
                var attachInfos = new List<CampAttachDto>();
                var arr = sceneMap.AttachNos?.Split(',');
                if (arr != null)
                {
                    foreach (var aNo in arr)
                    {
                        var attach = await rep2.FirstOrDefaultAsync(a => a.AttachNo == aNo);
                        if (attach != null)
                        {
                            attachInfos.Add(new CampAttachDto()
                            { AttachNo = aNo, CampNo = no, FileType = attach.FileType, FileTitle = attach.FileTitle, FileName = attach.FileName, FilePath = attach.FilePath });
                        }
                    }
                }
                return attachInfos;
            });
        }

        /// <summary>
        /// 获取分组运行的情景编码
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="no"></param>
        /// <param name="rep"></param>
        /// <returns></returns>
        public static async Task<ScenePathDto> GetSceneNos(this ICacheManager CacheManager, string no, IRepository<CampGroupInfo, string> rep)
        {
            return await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetAsync($"SceneNos-{no}", async () =>
            {
                var nos = new List<string>();
                var dataNode = await CacheManager.GetGroupRunningInfo(no, rep);
                var rounds = dataNode?.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                if (rounds != null)
                    foreach (var r in rounds)
                    {
                        var blocks = r.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                        if (blocks != null)
                            foreach (var b in blocks)
                            {
                                var flows = b.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                                if (flows != null)
                                    foreach (var f in flows)
                                    {
                                        var nodes = f.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                                        if (nodes != null)
                                            foreach (var node in nodes)
                                            {
                                                nos = GetSceneNoFromNode(nos, (FlowNodeDataNode)node);
                                            }
                                    }
                            }
                    }

                var dto = new ScenePathDto()
                {
                    hasChange = false,
                    PathList = nos
                };
                return dto;
            });
        }

        private static List<string> GetSceneNoFromNode(List<string> list, FlowNodeDataNode node)
        {
            list = list ?? new List<string>();
            if (node.SceneNodes != null)
            {
                var nos = node.SceneNodes.Select(a => a.Id).ToList();
                list.AddRange(nos);
            }
            var childNode = node.Children?.FirstOrDefault(a => a.IsStart);
            if (childNode != null)
            {
                list = GetSceneNoFromNode(list, (FlowNodeDataNode)childNode);
            }

            return list;
        }
    }
}