Atomx/Atomx.Data/CacheServices/AreaCacheService.cs

using Atomx.Common.Constants;
using Atomx.Common.Entities;
using Atomx.Common.Models;

namespace Atomx.Data.CacheServices
{
    public partial interface ICacheService
    {
        /// <summary>
        /// 获取国家数据
        /// </summary>
        /// <returns></returns>
        Task<List<Country>> GetCountries(bool? reload = false);

        /// <summary>
        /// 通过ID获取国家
        /// </summary>
        /// <param name="countryId"></param>
        /// <returns></returns>
        Task<Country> GetCountry(long countryId);

        /// <summary>
        /// 获取区域数据
        /// </summary>
        /// <param name="parentId"></param>
        /// <returns></returns>
        Task<List<StateProvince>> GetStateProvinces(long countryId, bool? reload = false);

        /// <summary>
        /// 获取州省数据
        /// </summary>
        /// <param name="countryId"></param>
        /// <param name="stateProvinceId"></param>
        /// <returns></returns>
        Task<StateProvince> GetStateProvince(long countryId, long stateProvinceId);

        /// <summary>
        /// 获取地区数据
        /// </summary>
        /// <param name="countryId"></param>
        /// <param name="reload"></param>
        /// <returns></returns>
        Task<List<Area>> GetAreas(long countryId, bool? reload = false);

        /// <summary>
        /// 更新调整缓存数据
        /// </summary>
        /// <param name="area"></param>
        /// <returns></returns>
        Task UpdateArea(Area area);

        /// <summary>
        /// 更新调整州省缓存数据
        /// </summary>
        /// <param name="stateProvince"></param>
        /// <returns></returns>
        Task UpdateStateProvince(StateProvince stateProvince);

        /// <summary>
        /// 更新调整国家缓存数据
        /// </summary>
        /// <param name="country"></param>
        /// <returns></returns>
        Task UpdateCountry(Country country);

        /// <summary>
        /// 获取国家-省份-城市树形数据
        /// </summary>
        /// <param name="countryId"></param>
        /// <returns></returns>
        Task<List<KeyValueTree>> GetAreaTree(long countryId, bool? reload = false);
    }
    public partial class CacheService : ICacheService
    {
        public async Task<List<KeyValueTree>> GetAreaTree(long countryId, bool? reload = false)
        {
            bool reloadData = reload.HasValue ? reload.Value : false;
            var cacheData = await GetCacheAsync<List<KeyValueTree>>($"{CacheKeys.CountryTree}{countryId}");
            if (cacheData == null || reloadData)
            {
                var states = await GetStateProvinces(countryId, true);
                var cities = await GetAreas(countryId, true);

                var tree = new List<KeyValueTree>();

                foreach (var state in states)
                {
                    var item = new KeyValueTree
                    {
                        Label = state.Name,
                        Value = state.Id.ToString()
                    };

                    var citysInState = cities.Where(p => p.StateProvinceId == state.Id).ToList();
                    foreach (var city in citysInState)
                    {
                        var cityItem = new KeyValueTree
                        {
                            Label = state.Name,
                            Value = state.Id.ToString()
                        };

                        cityItem.Children = BuildAreaTree(city.Id, cities, new List<KeyValueTree>());
                        item.Children.Add(cityItem);
                    }
                    tree.Add(item);

                }

                await SetCacheAsync($"{CacheKeys.CountryTree}{countryId}", tree);
            }
            return cacheData;
        }

        public async Task<List<Country>> GetCountries(bool? reload = false)
        {
            bool reloadData = reload.HasValue ? reload.Value : false;

            var cacheData = await GetCacheAsync<List<Country>>(CacheKeys.Country);
            if (cacheData == null || reloadData)
            {
                var countries = (from p in _dbContext.Countries
                                 where p.Enabled
                                 select p).ToList();
                await SetCacheAsync(CacheKeys.Country, countries);
                return countries;

            }
            return cacheData;
        }

        public async Task<Country> GetCountry(long countryId)
        {
            var cacheData = await GetCountries();
            var data = cacheData.SingleOrDefault(p => p.Id == countryId);
            return data;
        }

        /// <summary>
        /// 获取区域数据
        /// </summary>
        /// <param name="countryId"></param>
        /// <returns></returns>
        public async Task<List<StateProvince>> GetStateProvinces(long countryId, bool? reload = false)
        {
            bool reloadData = reload.HasValue ? reload.Value : false;
            var cacheData = await GetCacheAsync<List<StateProvince>>($"{CacheKeys.StateProvince}.{countryId}");
            if (cacheData == null || reloadData)
            {
                var stateProvinces = (from p in _dbContext.StateProvinces
                                      where p.CountryId == countryId && p.Enabled
                                      select p).ToList();
                await SetCacheAsync($"{CacheKeys.StateProvince}.{countryId}", stateProvinces);
                return stateProvinces;

            }
            return cacheData;
        }

        /// <summary>
        /// 获取州省数据
        /// </summary>
        /// <param name="stateProvinceId"></param>
        /// <returns></returns>
        public async Task<StateProvince> GetStateProvince(long countryId, long stateProvinceId)
        {
            var cacheData = await GetStateProvinces(countryId);
            var data = cacheData.SingleOrDefault(p => p.Id == stateProvinceId);
            return data;
        }

        /// <summary>
        /// 获取地区数据
        /// </summary>
        /// <param name="countryId"></param>
        /// <param name="reload"></param>
        /// <returns></returns>
        public async Task<List<Area>> GetAreas(long countryId, bool? reload = false)
        {
            var cacheData = await GetCacheAsync<List<Area>>($"{CacheKeys.City}.{countryId}");
            bool reloadData = reload.HasValue ? reload.Value : false;
            if (cacheData == null || reloadData)
            {
                List<Area> areas = new();
                var query = from p in _dbContext.Areas
                            where p.CountryId == countryId && p.Enabled
                            select p;
                var count = query.Count();
                int size = 50;
                var pageCount = (int)Math.Ceiling(count / (double)size) + 1;
                for (var i = 1; i < pageCount; i++)
                {
                    var list = query.Skip((i - 1) * size).Take(size).ToList();
                    areas.AddRange(list);
                }
                await SetCacheAsync(CacheKeys.Country, areas);
                return areas;
            }
            return cacheData;
        }

        public async Task UpdateArea(Area area)
        {
            var cacheData = await GetAreas(area.CountryId);
            var data = cacheData.Where(p => p.Id == area.Id).SingleOrDefault();
            if (data != null)
            {
                cacheData.Remove(data);
            }
            cacheData.Add(area);
            await SetCacheAsync($"{CacheKeys.City}.{area.CountryId}", cacheData);
        }



        /// <summary>
        /// 更新调整州省缓存数据
        /// </summary>
        /// <param name="stateProvince"></param>
        /// <returns></returns>
        public async Task UpdateStateProvince(StateProvince stateProvince)
        {
            var cacheData = await GetStateProvinces(stateProvince.CountryId);
            var data = cacheData.Where(p => p.Id == stateProvince.Id).SingleOrDefault();
            if (data != null)
            {
                cacheData.Remove(data);
            }
            cacheData.Add(stateProvince);
            await SetCacheAsync($"{CacheKeys.StateProvince}.{stateProvince.CountryId}", cacheData);
        }

        /// <summary>
        /// 更新调整国家缓存数据
        /// </summary>
        /// <param name="country"></param>
        /// <returns></returns>
        public async Task UpdateCountry(Country country)
        {
            var cacheData = await GetCountries();
            var data = cacheData.Where(p => p.Id == country.Id).SingleOrDefault();
            if (data != null)
            {
                cacheData.Remove(data);
            }
            cacheData.Add(country);
            await SetCacheAsync($"{CacheKeys.Country}", cacheData);
        }

        private List<KeyValueTree> BuildAreaTree(long parentId, List<Area> areas, List<KeyValueTree> result)
        {
            var data = areas.Where(p => p.ParentId == parentId).ToList();
            foreach (var area in areas)
            {
                var item = new KeyValueTree
                {
                    Label = area.Name,
                    Value = area.Id.ToString()
                };
                var childs = areas.Where(p => p.ParentId == area.Id).ToList();
                if (childs.Count > 0)
                {
                    var childrenTrees = BuildAreaTree(area.Id, areas, result);
                    item.Children.AddRange(childrenTrees);
                }
                result.Add(item);
            }
            return result;
        }
    }
}