dotnet/molilian.core/Core/taoke/TkPoolCore.cs

using dodohold.core;
using YunhuiKit;


namespace molilian.core
{
    public partial class TkPoolCore
    {
        public enum TkAction
        {
            all,
            parse,
            coupon,
            promotionQuery
        }

        private static string _end_point;
        static TkPoolCore()
        {
            _end_point = Environment.GetEnvironmentVariable("EndPoint");
        }

        private static SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

        private static IEnumerable<TkPoolDTO> _cached;
        private static IEnumerable<TkPoolDTO> _all_cached;

        public static async Task<TkPoolDTO> GetOneAsync(int id)
        {
            var list = await ListAsync();
            if (!list.Any()) return null;
            return list.Where(e => e.id == id).FirstOrDefault();
        }

        public static async Task<TkPoolDTO> GetOneAsync2(TkAction action)
        {
            var list = await ListAsync().ConfigureAwait(false);
            if (!list.Any()) return null;

            // 线程安全的随机排序
            var random = new Random(Guid.NewGuid().GetHashCode());
            var shuffled = list.OrderBy(_ => random.Next()).ToList();

            foreach (var item in shuffled)
            {
                if (await FilterNodesAsync(item, action).ConfigureAwait(false))
                    return item;
            }
            return null;
        }
        public static async Task<TkPoolDTO> GetOneAsync(TkAction action, bool isTaobaoUrl, string riskStrategy)
        {
            var list = await ListAsync().ConfigureAwait(false);
            if (!list.Any())
                return null;

            if ("brw".Equals(riskStrategy))
            {
                list = list.Where(item => "brw".Equals(item.riskStrategy)).ToList();
                if (!list.Any()) return null;
            }
            else
            {
                list = list.Where(item => !"brw".Equals(item.riskStrategy)).ToList();
                if (!list.Any()) return null;
            }

            var filteredList = new List<TkPoolDTO>();
            foreach (var item in list)
            {
                // 检查是否有账号关联了当前账号
                var ownerAccount = list.FirstOrDefault(other =>
                    other.id != item.id &&
                    !string.IsNullOrEmpty(other.related_account_ids) &&
                    other.related_account_ids.Split(',').Contains(item.id.ToString()));

                // 如果没有账号关联它，或者关联它的账号在线，则可以使用
                if (ownerAccount == null || list.Any(a => a.id == ownerAccount.id))
                {
                    // 如果收单账号不在线，跳过这个关联账号
                    if (!list.Any(a => a.id == ownerAccount.id))
                        continue;
                }
                
                // 如果不是关联账号，或者收单账号在线，则可以使用
                    filteredList.Add(item);
                }
            }

            if (filteredList.Count == 0) return null;

            // 1. 筛选出有可用端点的账号池，并计算权重
            var weightedAccounts = new List<(TkPoolDTO account, int weight)>();
            var random = new Random(Guid.NewGuid().GetHashCode()); // 避免重复种子问题

            foreach (var item in filteredList)
            {
                // 获取账号关联的所有端点配置
                var endpoints = await TkEndpointCore.GetEndpointsByAccountAsync(item.id, isTaobaoUrl, item.parseEndpoint);
                if (endpoints == null || endpoints.Count == 0)
                    continue;

                // 过滤可用端点（状态正常且未达限制）
                var availableEndpoints = endpoints
                    .Where(e => e.status)
                    .Where(e => e.hourly_calls_limit <= 0 || e.current_hourly_calls < e.hourly_calls_limit)
                    .Where(e => e.daily_calls_limit <= 0 || e.current_daily_calls < e.daily_calls_limit)
                    .Where(e => !TkEndpointManager.IsEndpointSuspended(item.id, e.endpoint)) // 直接检查端点对象
                    .ToList();

                if (availableEndpoints.Count == 0) continue;

                // 计算账号权重（基于剩余调用量）
                int weight = availableEndpoints.Sum(e =>
                    e.hourly_calls_limit <= 0 ? 3600 : e.hourly_calls_limit - e.current_hourly_calls);

                weightedAccounts.Add((item, weight));
            }

            if (weightedAccounts.Count == 0) return null;

            // 2. 加权随机选择
            int totalWeight = weightedAccounts.Sum(x => x.weight);
            int randomNumber = random.Next(0, totalWeight);

            foreach (var (account, weight) in weightedAccounts)
            {
                if (randomNumber < weight)
                {
                    if (await FilterNodesAsync(account, action).ConfigureAwait(false))
                        return account;
                    break; // 如果过滤失败，跳出当前循环
                }
                randomNumber -= weight;
            }

            // 3. 如果加权选择失败，回退到简单随机选择
            var fallbackCandidates = weightedAccounts
                .OrderBy(_ => random.Next())
                .Select(x => x.account);

            foreach (var account in fallbackCandidates)
            {
                if (await FilterNodesAsync(account, action).ConfigureAwait(false))
                    return account;
            }
            return null;
        }

        private static async Task<bool> FilterNodesAsync(TkPoolDTO item, TkAction action)
        {
            if (!string.IsNullOrEmpty(item.suspended_endpoint) && item.suspended_endpoint.Contains($"{_end_point}|")) return false;

            if (!string.IsNullOrEmpty(_end_point) && !string.IsNullOrEmpty(item.end_point))
            {
                if (item.end_point != _end_point) return false;
            }

            // 使用初始化参数创建工作时间表
            if (!new WorkSchedule(item.time_range).IsWorkHour()) return false;

            if (item.daily_calls_limit > 0)
            {
                int daily_num = RiskControlCore.GetCalls(TkChannelEnum.tb, item.id, DateTime.Now.ToString("yyyyMMdd"));
                if (daily_num >= item.daily_calls_limit) return false;
            }
            if (item.hourly_calls_limit > 0)
            {
                int hourly_num = RiskControlCore.GetCalls(TkChannelEnum.tb, item.id, DateTime.Now.ToString("yyyyMMddHH"));
                if (hourly_num >= item.hourly_calls_limit) return false;
            }
            var endpointCheck = await TkEndpointManager.HasAvailableEndpointAsync(item.id).ConfigureAwait(false);

            if (!endpointCheck) return false;


            switch (action)
            {
                case TkAction.parse:
                    if (!item.enable_parse) return false;
                    break;
                case TkAction.promotionQuery:
                    if (!item.enable_promotionQuery) return false;
                    break;
                case TkAction.coupon:
                    if (!item.enable_coupon) return false;
                    break;
            }

            if (item.daily_income_limit == 0) return true;
            decimal income_amt = RiskControlCore.GetIncomeAmt(TkChannelEnum.tb, $"{item.id}");
            return income_amt < item.daily_income_limit;
        }


        public static async Task<IEnumerable<TkPoolDTO>> AllListAsync(bool force = false)
        {
            if (!force && _all_cached != default) return _all_cached;

            try
            {
                await _semaphore.WaitAsync();

                string cache_key = $"cache:all_tk_pool";
                var list = await RedisKit.GetAsync<IEnumerable<TkPoolDTO>>(cache_key);

                if (force || list == default)
                {
                    list = new DBContext.Table("tk_pool").Select<TkPoolDTO>();
                    if (list == null) return default;

                    // 等待 Redis 写入完成
                    await RedisKit.SetAsync(cache_key, list, 30 * 86400);
                }

                _all_cached = list;
                return list;
            }
            catch (Exception)
            {
                // 发生异常时返回上一次的缓存，如果没有则返回默认值
                return _all_cached ?? default;
            }
            finally
            {
                _semaphore.Release();
            }
        }

        public static async Task<IEnumerable<TkPoolDTO>> ListAsync(bool force = false)
        {
            // 内存缓存检查
            if (!force && _cached != null) return _cached;
            string cache_key = "cache:tk_pool";

            if (!force)
            {
                var cachedList = await RedisHelper.GetAsync<IEnumerable<TkPoolDTO>>(cache_key);
                if (cachedList != null)
                {
                    _cached = cachedList;
                    return cachedList;
                }
            }
            // 获取新数据
            await _semaphore.WaitAsync();
            try
            {
                // 双重检查，防止并发情况下重复加载
                if (!force)
                {
                    var cachedList = await RedisHelper.GetAsync<IEnumerable<TkPoolDTO>>(cache_key);
                    if (cachedList != null)
                    {
                        _cached = cachedList;
                        return cachedList;
                    }
                }

                // 从数据库加载数据
                var list = new DBContext.Table("tk_pool")
                    .Where("status=@status", new { status = 1 })
                    .Select<TkPoolDTO>();

                if (list == null) return default;

                // 更新调用次数
                foreach (var item in list)
                {
                    _ = RiskControlCore.SetCallsAsync(TkChannelEnum.tb, item.id, DateTime.Now.ToString("yyyyMMddHH"), item.current_hourly_calls);
                    _ = RiskControlCore.SetCallsAsync(TkChannelEnum.tb, item.id, DateTime.Now.ToString("yyyyMMdd"), item.current_daily_calls);
                }

                // 更新缓存
                await RedisHelper.SetAsync(cache_key, list, 30 * 86400);
                _cached = list;
                return list;
            }
            finally
            {
                _semaphore.Release();
            }
        }

        public static void Refresh()
        {
            _ = AllListAsync(true);
            _ = ListAsync(true);
            TkEndpointCore.Refresh();
            TkEndpointManager.Refresh();
        }
        public static void UpdateDrawBalance(string name, decimal amout)
        {
            new DBContext.Table("tk_pool")
                .Add("draw_balance", amout)
                .Where("name=@name", new { name })
                .Update();
            _ = ListAsync(true);
        }

        public static void Suspend(string endpoint, int accountId, string name, string content)
        {
            string cache_key = $"cache:tk_pool:{accountId}:suspend";
            long count = RedisHelper.IncrBy(cache_key);
            RedisHelper.Expire(cache_key, 10);
            if (count > 1) return;

            var update = new DBContext.Table("tk_pool").Add("suspended_endpoint:", $"CONCAT(suspended_endpoint, '{endpoint},')");

            if (accountId > 0)
            {
                update.Where("id=@accountId", new { accountId }).Update();
            }
            else
            {
                update.Where("name=@name", new { name }).Update();
            }
            _ = ListAsync(true);
            NotifyCore.Notify(new NifyMessage
            {
                message = $"【淘客{accountId}:{name}】{endpoint} 暂停",
                priority = NifyMessagePriority.high,
                tags = ["red_circle"]
            });
            NotifyCore.AnPushNotify("暂停", $"【淘客{accountId}:{name}】{endpoint} 暂停");
            EndPointCore.NotifyReload(true);
        }

        public static void Disabled(int accountId, string name, string content)
        {
#if DEBUG
#else
#endif
            string cache_key = $"cache:tk_pool:{accountId}:disabled";
            long count = RedisHelper.IncrBy(cache_key);
            RedisHelper.Expire(cache_key, 10);
            if (count > 1) return;

            var update = new DBContext.Table("tk_pool").Add("status", 0);
            if (accountId > 0)
            {
                update.Where("id=@accountId", new { accountId }).Update();
            }
            else
            {
                update.Where("name=@name", new { name }).Update();
            }

            _ = ListAsync(true);

            NotifyCore.Notify(new NifyMessage
            {
                message = $"【淘客{accountId}:{name}】cookie 掉线\n\n{content}",
                priority = NifyMessagePriority.high,
                tags = ["red_circle"]
            });

            NotifyCore.AnPushNotify("掉线", $"【淘客{accountId}:{name}】cookie 掉线");
            EndPointCore.NotifyReload(true);
        }

        public static int UpdateCookies(string cookies, string user_agent)
        {
            if (string.IsNullOrEmpty(cookies)) return 0;
            cookies += ";";
            string dnk = cookies.GetContentPart("dnk=", ";");
            string company = dnk;
            int accountId = 0;
            string tb_token = cookies.GetContentPart("_tb_token_=", ";");
            if (string.IsNullOrEmpty(dnk) || string.IsNullOrEmpty(tb_token)) return 0;
            var exist = new DBContext.Table("tk_pool").Fields("id, name, company, refpid, status").Get<dynamic>("name=@dnk", new { dnk });
            if (exist != null)
            {
                int status = exist.status;
                string refpid = exist.refpid;
                company = exist.company;
                accountId = exist.id;
                if (!string.IsNullOrEmpty(refpid)) status = 1;
                new DBContext.Table("tk_pool")
                   .Add("name", dnk)
                   .Add("tb_token", tb_token)
                   .Add("cookies", cookies)
                   .Add("user_agent", user_agent)
                   .Add("status", status)
                   .Add("suspended_endpoint", string.Empty)
                   .Add("last_time", DateTime.Now)
                   .Add("login_time", DateTime.Now)
                   .Where("id=@id", new { exist.id })
                   .Update();
                if (status == 1) _ = ListAsync(true);
            }
            else
            {
                accountId = new DBContext.Table("tk_pool")
                    .Add("name", dnk)
                    .Add("description", "由cookies上报创建此记录")
                    .Add("tb_token", tb_token)
                    .Add("refpid", string.Empty)
                    .Add("cookies", cookies)
                    .Add("user_agent", user_agent)
                    .Add("create_time", DateTime.Now)
                    .Add("last_time", DateTime.Now)
                    .Add("login_time", DateTime.Now)
                    .Add("status", 0)
                    .Create();
            }

            NotifyCore.Notify(new NifyMessage
            {
                message = $"【淘客{accountId}:{company}】cookie 上线",
                tags = ["green_circle"]
            });
            EndPointCore.NotifyReload(true);
            //NotifyCore.AnPushNotify("上线", $"【淘宝联盟:{dnk}】cookie 上报更新");
            return accountId;
        }

        internal static void AccountExhausted()
        {
            string cache_key = $"cache:tk_pool:account:exhausted";
            long count = RedisHelper.IncrBy(cache_key);
            if (count > 1) return;
            RedisHelper.Expire(cache_key, 3600);
            NotifyCore.Notify(new NifyMessage
            {
                message = $"【淘客】没有匹配账号",
                priority = NifyMessagePriority.high,
                tags = ["red_circle"]
            });
            NotifyCore.AnPushNotify("没账号", $"【淘客】没有匹配账号");
        }
    }

}