public override void Execute()
        {
            this._site.FilterConfig.Filters.Clear();
            ItemFilterCache.SaveConfig(this._site.FilterConfig);

            Response.WriteAsync(JsonUtil.Serialize(new { }));
        }
        public override void Execute()
        {
            var id = this.GetQuery <string>("id");

            var filter = this._site.FilterConfig.Filters.FirstOrDefault(p => p.Id == id);

            if (filter != null)
            {
                this._site.FilterConfig.Filters.Remove(filter);
                ItemFilterCache.SaveConfig(this._site.FilterConfig);
            }

            Response.WriteAsync(JsonUtil.Serialize(new { }));
        }
        public override void Execute()
        {
            var filter = this.GetPostData <ItemFilter>();

            filter.Id = Guid.NewGuid().ToString();
            foreach (var item in filter.Items)
            {
                item.DisplayName = ItemFilterHelper.EquipFilterDict[item.Name];
            }

            this._site.FilterConfig.Filters.Add(filter);
            ItemFilterCache.SaveConfig(this._site.FilterConfig);

            Response.WriteAsync(JsonUtil.Serialize(new { }));
        }
        private void ParseCookies(IOwinRequest request)
        {
            var charId = request.Cookies["charaId"];

            if (!string.IsNullOrEmpty(charId))
            {
                _site.CurrentCharId = charId;
                _site.Config        = CharacterConfigCache.TryGetValue(charId, CharacterConfigCache.LoadConfig);
                _site.Dynamic       = CharacterDynamicCache.TryGetValue(charId, CharacterDynamicCache.LoadDynamic);
                _site.FilterConfig  = ItemFilterCache.TryGetValue(charId, ItemFilterCache.LoadConfig);

                string ip = GetRealIP();
                if (!_site.Config.IPList.Contains(ip))
                {
                    _site.Config.IPList.Add(ip);
                    CharacterConfigCache.SaveConfig(_site.Config);
                }
            }
        }
Example #5
0
        public override void Execute()
        {
            string name = this.GetQuery <string>("name");

            var c = CharacterCache.GetAll().FirstOrDefault(p => p.Name == name);

            if (c != null)
            {
                if (ItemFilterCache.HasCache(c.Id))
                {
                    var cfg = ItemFilterCache.LoadCache(c.Id);

                    this._site.FilterConfig.Filters.Clear();

                    foreach (var p in cfg.Filters)
                    {
                        var newFilter = new ItemFilter()
                        {
                            Color        = p.Color,
                            RealCategory = p.RealCategory,
                            Id           = Guid.NewGuid().ToString(),
                            Items        = new List <ItemFilterItem>(),
                        };
                        foreach (var item in p.Items)
                        {
                            newFilter.Items.Add(new ItemFilterItem
                            {
                                DisplayName = item.DisplayName,
                                Name        = item.Name,
                                Value       = item.Value,
                            });
                        }

                        this._site.FilterConfig.Filters.Add(newFilter);
                    }

                    ItemFilterCache.SaveConfig(this._site.FilterConfig);
                }
            }

            Response.WriteAsync(JsonUtil.Serialize(new { }));
        }
Example #6
0
        public override void Execute()
        {
            var allMaps     = this._site.InitAllMaps();
            var dynamicList = CharacterDynamicCache.LoadAllDynamics();

            foreach (var cd in dynamicList)
            {
                foreach (var mi in cd.ItemList)
                {
                    var map = allMaps.FirstOrDefault(p => p.MapId == mi.Key);
                    if (map != null)
                    {
                        foreach (var item in mi.Value)
                        {
                            if (!map.ItemsVoList.ContainsKey(item.Key))
                            {
                                map.ItemsVoList[item.Key] = item.Value;
                            }
                        }
                    }
                }
            }

            var cfgList = CharacterConfigCache.LoadAllConfigs();

            foreach (var cfg in cfgList)
            {
                InfinityServerSite site = new InfinityServerSite(this._site.Uri, this.Request, this.Response);
                site.CurrentCharId = cfg.CharId;
                site.Config        = CharacterConfigCache.TryGetValue(cfg.CharId, CharacterConfigCache.LoadConfig);
                site.Dynamic       = CharacterDynamicCache.TryGetValue(cfg.CharId, CharacterDynamicCache.LoadDynamic);
                site.FilterConfig  = ItemFilterCache.TryGetValue(cfg.CharId, ItemFilterCache.LoadConfig);
                try
                {
                    site.InitChar();

                    var group = site.InitArmyGroup();

                    if (cfg.IsGuaji)
                    {
                        if (group == null)
                        {
                            BattleScheduler.AddChar(site);
                        }
                        else
                        {
                            site.Config.IsGuaji = false;
                            CharacterConfigCache.SaveConfig(site.Config);
                        }
                    }
                    if (cfg.IsDungeonGuaji)
                    {
                        if (group != null)
                        {
                            if (site.CheckIsGroupCaption())
                            {
                                BattleScheduler.AddChar(site, true);
                            }
                            else
                            {
                                site.Config.IsDungeonGuaji = false;
                                CharacterConfigCache.SaveConfig(site.Config);
                            }
                        }
                    }
                }
                catch { }
            }

            Response.WriteAsync(JsonUtil.Serialize(new { }));
        }