WEP_V2.1.3/SourceCode/We.AppOnline/WeOnlineApp.Core/Configuration/Cache/CacheMangerEx.cs

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

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

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

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

using WeOnlineApp.BaseInfo;
using WeOnlineApp.TrainingCamp;

namespace WeOnlineApp.Configuration.Cache
{
    public static class CacheMangerEx
    {
        public static bool HasLoadPackageCache;

        public static async Task LoadPackageInfos(this ICacheManager CacheManager, string urlPrev)
        {
            if (HasLoadPackageCache)
            {
                HasLoadPackageCache = false;
                var list = GetPackageInfos(CacheManager, urlPrev);
                foreach (var p in list)
                {
                    await Task.Run(() => GetPackageInfo(CacheManager, p.Id, urlPrev));
                    await Task.Run(() => GetPackageDetail(CacheManager, p.Id, urlPrev));
                    await Task.Run(() => GetPackageXmlInfos(CacheManager, p.Id, urlPrev));
                    await Task.Run(() => GetPackageNode(CacheManager, p.Id, urlPrev));
                    await Task.Run(() => GetPackageDataNode(CacheManager, p.Id, urlPrev));
                }
            }
        }

        /// <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 xml = GetPackageXmlInfos(CacheManager, no, urlPrev);
                var package = xml.ToPackage();
                return package;
            });
        }

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

        public static PackageDataNode GetFullRunPackageDataNode(this ICacheManager CacheManager, PackageDataNode runNode, string urlPrev)
        {
            return CacheManager.GetCache(IwbCacheNames.PackageInfoCache).Get($"XML_DATA_NODE{runNode.Id}", () =>
            {
                var package = GetPackageNode(CacheManager, runNode.PackageNo, urlPrev);
                var runPackage = (PackageNode)runNode.ConvertToNode(package);
                var fullRunNode = runPackage.Convert2DataNode(true);
                return fullRunNode;
            });
        }

        /// <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<CampPlayScoreInfo> GetGroupRoundScoreAsync(this ICacheManager CacheManager, string no, int round, IRepository<CampPlayScoreInfo> rep)
        {
            return await CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache).GetAsync($"SCORE-{no}-{round}", async () =>
               {
                   var gs = await rep.FirstOrDefaultAsync(a => a.PlayNo == no && a.RoundIndex == round);
                   return gs;
               });
        }

        public static CampPlayScoreInfo GetGroupRoundScore(this ICacheManager CacheManager, string no, int round, IRepository<CampPlayScoreInfo> rep)
        {
            return CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache).Get($"SCORE-{no}-{round}", () =>
             {
                 var gs = rep.FirstOrDefault(a => a.PlayNo == no && a.RoundIndex == round);
                 return gs;
             });
        }

        public static Task SetGroupRoundScoreAsync(this ICacheManager CacheManager, string no, int round, CampPlayScoreInfo ps)
        {
            return CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache).SetAsync($"SCORE-{no}-{round}", ps);
        }

        public static void SetGroupRoundScore(this ICacheManager CacheManager, string no, int round, CampPlayScoreInfo ps)
        {
            CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache).Set($"SCORE-{no}-{round}", ps);
        }

        /// <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(',').OrderBy(a => a).ToList();
               return list;
           });
        }

        /// <summary>
        /// 获取分组运行信息
        /// </summary>
        /// <returns></returns>
        public static async Task<PackageDataNode> GetGroupRunningInfoAsync(this ICacheManager CacheManager, string no, IRepository<CampPlayInfo, string> rep)
        {
            var runGroupInfo = await CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache)
                .GetAsync(no, async () =>
                {
                    var entity = await rep.GetAll().Where(a => a.Id == no).Select(a => new { a.Name, a.RunningInfo })
                        .FirstOrDefaultAsync();
                    var info = entity?.RunningInfo?.Str2Obj<PackageDataNode>();
                    if (info != null)
                    {
                        info.Name = entity.Name;
                    }
                    return info;
                });
            return runGroupInfo;
        }

        /// <summary>
        /// 获取分组运行信息
        /// </summary>
        /// <returns></returns>
        public static PackageDataNode GetGroupRunningInfo(this ICacheManager CacheManager, string no, IRepository<CampPlayInfo, string> rep)
        {
            var runGroupInfo = CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache)
                .Get(no, () =>
               {
                   var entity = rep.GetAll().Where(a => a.Id == no).Select(a => new { a.Name, a.RunningInfo })
                       .FirstOrDefault();
                   var info = entity?.RunningInfo?.Str2Obj<PackageDataNode>();
                   if (info != null)
                   {
                       info.Name = entity.Name;
                   }
                   return info;
               });
            return runGroupInfo;
        }

        /// <summary>
        /// 缓存分组运行信息
        /// </summary>
        /// <returns></returns>
        public static Task SetGroupRunningInfoAsync(this ICacheManager CacheManager, string no, PackageDataNode runNode)
        {
            return CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache)
                .SetAsync(no, runNode);
        }

        /// <summary>
        /// 缓存分组运行信息
        /// </summary>
        /// <returns></returns>
        public static void SetGroupRunningInfo(this ICacheManager CacheManager, string no, PackageDataNode runNode)
        {
            CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache)
               .Set(no, runNode);
        }

        /// <summary>
        /// 缓存分组运行信息
        /// </summary>
        /// <returns></returns>
        public static Task SetGroupRunningInfoAsync(this ICacheManager CacheManager, string no, string runInfo)
        {
            var runNode = runInfo.Str2Obj<PackageDataNode>();
            return CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache)
                .SetAsync(no, runNode);
        }

        /// <summary>
        /// 缓存分组运行信息
        /// </summary>
        /// <returns></returns>
        public static void SetGroupRunningInfo(this ICacheManager CacheManager, string no, string runInfo)
        {
            var runNode = runInfo.Str2Obj<PackageDataNode>();
            CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache)
               .Set(no, runNode);
        }

        /// <summary>
        /// 获取分组运行信息
        /// </summary>
        /// <returns></returns>
        public static async Task<CampPlayInfo> GetPlayInfoAsync(this ICacheManager CacheManager, string no, IRepository<CampPlayInfo, string> rep)
        {
            var playInfo = await CacheManager.GetCache(IwbCacheNames.PlayInfoCache)
                .GetAsync(no, async () =>
                {
                    var info = await rep.GetAllIncluding(a => a.CampInfo).FirstOrDefaultAsync(a => a.Id == no);
                    return info;
                });
            return playInfo;
        }

        /// <summary>
        /// 获取分组运行信息
        /// </summary>
        /// <returns></returns>
        public static CampPlayInfo GetPlayInfo(this ICacheManager CacheManager, string no, IRepository<CampPlayInfo, string> rep)
        {
            var playInfo = CacheManager.GetCache(IwbCacheNames.PlayInfoCache)
                .Get(no, () =>
                {
                    var info = rep.GetAllIncluding(a => a.CampInfo).FirstOrDefault(a => a.Id == no);
                    return info;
                    //try
                    //{
                    //    var query = rep.GetAllIncluding(a => a.CampInfo);
                    //    var q = from a in query
                    //            where a.Id == no
                    //            select new
                    //            {
                    //                Id = a.Id,
                    //                Name = a.Name,
                    //                CampInfo = a.CampInfo,
                    //                StartDate = a.StartDate,
                    //                EndDate = a.EndDate,
                    //                CampNo = a.CampNo,
                    //                RoundIndex = a.RoundIndex,
                    //                InvitationCode = a.InvitationCode,
                    //                IsPublic = a.IsPublic,
                    //                PlayState = a.PlayState,
                    //                PlayRoleNames = a.PlayRoleNames,
                    //                TrainingMinute = a.TrainingMinute,
                    //                PlayModel = a.PlayModel,
                    //                Remark = a.Remark,
                    //                a.CreatorUserId,
                    //                a.CreatorUser,
                    //                a.CreationTime,
                    //            };
                    //    var info = q.FirstOrDefault()?.Obj2String().Str2Obj<CampPlayInfo>();
                    //    if (info != null)
                    //    {
                    //        info.RunningInfo = GetGroupRunningInfo(CacheManager, no, rep).Obj2String();
                    //    }
                    //    return info;
                    //}
                    //catch (Exception e)
                    //{
                    //    Console.WriteLine(e);
                    //    return null;
                    //}
                });
            return playInfo;
        }

        /// <summary>
        /// 缓存运行分组
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static async Task SetPlayInfoAsync(this ICacheManager CacheManager, CampPlayInfo entity)
        {
            await CacheManager.GetCache(IwbCacheNames.PlayInfoCache).SetAsync(entity.Id, entity);
        }

        /// <summary>
        /// 缓存运行分组缓存
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="entity"></param>
        public static void SetPlayInfo(this ICacheManager CacheManager, CampPlayInfo entity)
        {
            CacheManager.GetCache(IwbCacheNames.PlayInfoCache).Set(entity.Id, entity);
        }

        /// <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> GetSceneListAsync(this ICacheManager CacheManager, string no, IRepository<CampPlayInfo, string> rep)
        {
            return await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetAsync($"SceneNos-{no}", async () =>
            {
                var nos = new List<string>();
                var runGroupInfo = await CacheManager.GetGroupRunningInfoAsync(no, rep);
                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)
                                            {
                                                nos = GetSceneNoFromNode(nos, node);
                                            }
                                    }
                            }
                    }

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

        /// <summary>
        /// 获取分组运行的情景编码
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="no"></param>
        /// <param name="rep"></param>
        /// <returns></returns>
        public static ScenePathDto GetScenePathList(this ICacheManager CacheManager, string no, IRepository<CampPlayInfo, string> rep)
        {
            return CacheManager.GetCache(IwbCacheNames.SceneInfoCache).Get($"SceneNos-{no}", () =>
          {
              var nos = new List<string>();
              var runGroupInfo = CacheManager.GetGroupRunningInfo(no, rep);
              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)
                                          {
                                              nos = GetSceneNoFromNode(nos, node);
                                          }
                                  }
                          }
                  }

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

        /// <summary>
        /// 缓存分组运行的情景编码
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="path"></param>
        /// <param name="paths"></param>
        /// <returns></returns>
        public static Task SetSceneNosAsync(this ICacheManager CacheManager, string path, ScenePathDto paths)
        {
            return CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"ScenePath-{path}", paths);
        }

        /// <summary>
        /// 缓存分组运行的情景编码
        /// </summary>
        /// <param name="CacheManager"></param>
        /// <param name="path"></param>
        /// <param name="paths"></param>
        /// <returns></returns>
        public static void SetScenePathList(this ICacheManager CacheManager, string path, ScenePathDto paths)
        {
            CacheManager.GetCache(IwbCacheNames.SceneInfoCache).Set($"ScenePath-{path}", paths);
        }

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

            return list;
        }
    }
}