dotnet/molilian.core/Core/pdd/PddPoolCore.cs

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.Filters;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using dodohold.core;
using Dataoke;
using Google.Protobuf.WellKnownTypes;
using System.Diagnostics;
using System.Text.Json;
using TencentCloud.Tcm.V20210413.Models;
using System.Security.Cryptography;
using System.Collections.Concurrent;
using YunhuiKit;
using Microsoft.AspNetCore.Components.RenderTree;


namespace molilian.core
{
    public partial class PddPoolCore
    {
        private static readonly object _lockObj = new();
        private static IEnumerable<PddPoolDTO> _cached;
        private static IEnumerable<PddPoolDTO> _all_cached;

        private static string _end_point;
        private static Dictionary<string, decimal> _incomeAmt = new();
        private static ConcurrentDictionary<int, DateTime> _suspend = new();
        
        // 添加本地内存统计 - 线程安全
        private static readonly ConcurrentDictionary<string, int> _dailyUsage = new();
        private static volatile string _currentDay = DateTime.Now.ToString("yyyyMMdd");
        private static readonly object _dayResetLock = new object(); // 专用于日期重置的锁

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

        static PddPoolCore()
        {
            _end_point = Environment.GetEnvironmentVariable("EndPoint");
        }

        public static PddPoolDTO? GetOne(PddUnionWorkMode mode, int accountid = 0, string parse_type = "")
        {
            var list = List();
            if (!list.Any()) return null;
            if ("dp".Equals(parse_type))
            {
                list = list.Where(item => "dp".Equals(item.parse_type)).ToList();
                if (!list.Any()) return null;
            }
            else
            {
                list = list.Where(item => string.IsNullOrEmpty(item.parse_type)).ToList();
                if (!list.Any()) return null;

            }

            return list.Where(e => IsMatch(e, mode, accountid))
                .OrderBy(account => GetCurrentDayUsage(account.id))
                .ThenBy(account => account.id) // 相同使用次数时按ID排序，确保稳定性
                .FirstOrDefault();
        }

        private static int GetCurrentDayUsage(int accountId)
        {
            CheckAndResetDailyStats();
            string currentDay = _currentDay; // 获取当前快照，避免在构建key过程中被修改
            string key = $"{accountId}_{currentDay}";
            return _dailyUsage.GetOrAdd(key, 0);
        }

        private static void CheckAndResetDailyStats()
        {
            var today = DateTime.Now.ToString("yyyyMMdd");
            
            // 使用volatile读取，如果日期相同则直接返回，避免锁开销
            if (today == _currentDay) return;
            
            // 只有在日期不同时才尝试获取锁
            lock (_dayResetLock)
            {
                // 双重检查：再次验证日期是否需要重置
                if (today != _currentDay)
                {
                    // 清空所有统计数据
                    _dailyUsage.Clear();
                    
                    // 原子性更新当前日期（volatile写入）
                    _currentDay = today;
                    
                    // 可选：记录日期切换日志
                    Console.WriteLine($"Daily stats reset for date: {today}");
                }
            }
        }


        internal static void UpdateAccountUsage(int accountId)
        {
            CheckAndResetDailyStats();
            string currentDay = _currentDay; // 获取当前快照，确保一致性
            string key = $"{accountId}_{currentDay}";
            
            // 使用AddOrUpdate确保原子性递增
            _dailyUsage.AddOrUpdate(key, 1, (k, oldValue) => oldValue + 1);
        }

        /// <summary>
        /// 获取当前统计信息（用于监控和调试）
        /// </summary>
        internal static Dictionary<string, int> GetCurrentUsageSnapshot()
        {
            CheckAndResetDailyStats();
            return new Dictionary<string, int>(_dailyUsage);
        }

        /// <summary>
        /// 强制清理统计数据（仅用于测试或紧急情况）
        /// </summary>
        internal static void ForceClearStats()
        {
            lock (_dayResetLock)
            {
                _dailyUsage.Clear();
                Console.WriteLine("Force cleared daily usage stats");
            }
        }

        internal static void TempSuspend(int accountId)
        {
            _suspend.AddOrUpdate(accountId, DateTime.Now, (key, oldValue) => DateTime.Now);
        }

        private static bool IsMatch(PddPoolDTO item, PddUnionWorkMode mode, int accountid)
        {
            if (accountid != 0 && accountid != item.id) return false;
            if (!item.enable_parse) return false;
            if (mode != PddUnionWorkMode.All && mode != item.work_mode) return false;
            if (item.work_mode == PddUnionWorkMode.Crawler && !item.cookie_status) 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 (_suspend.TryGetValue(accountid, out DateTime suspendTime))
            {
                var ts = DateTime.Now - suspendTime;
                if (ts.TotalSeconds < 70) return false;
            }

            if (item.cis_limit > 0)
            {
                string lockKey = $"pdd_cis_limit_{accountid}";
                int cis_num = RedisHelper.Get<int>(lockKey);
                if (cis_num > 0) return false;
            }
            if (item.rpm_limit > 0)
            {
                int rpm_num = RiskControlCore.GetCalls(TkChannelEnum.pdd, item.id, DateTime.Now.ToString("yyyyMMddHHmm"));
                if (rpm_num >= item.rpm_limit) return false;
            }
            if (item.daily_calls_limit > 0)
            {
                int daily_num = RiskControlCore.GetCalls(TkChannelEnum.pdd, 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.pdd, item.id, DateTime.Now.ToString("yyyyMMddHH"));
                if (hourly_num >= item.hourly_calls_limit) return false;
            }
            return true;
        }



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

            try
            {
                await _semaphore.WaitAsync();

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

                if (force || list == default)
                {
                    list = new DBContext.Table("pdd_pool").Select<PddPoolDTO>();
                    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 IEnumerable<PddPoolDTO> List(bool force = false)
        {
            if (!force && _cached != null) return _cached;

            string cache_key = $"cache:pdd_pool";
            var list = RedisHelper.Get<IEnumerable<PddPoolDTO>>(cache_key);
            if (force || list == null)
            {
                lock (_lockObj)
                {
                    list = new DBContext.Table("pdd_pool")
                        .Where("status=@status", new { status = 1 })
                        .Select<PddPoolDTO>();
                    if (list == null) return default;
                    foreach (var item in list)
                    {
                        RiskControlCore.SetCallsAsync(TkChannelEnum.pdd, item.id, DateTime.Now.ToString("yyyyMMddHH"), item.current_hourly_calls);
                        RiskControlCore.SetCallsAsync(TkChannelEnum.pdd, item.id, DateTime.Now.ToString("yyyyMMdd"), item.current_daily_calls);
                    }
                    RedisHelper.Set(cache_key, list, 30 * 86400);
                }
            }
            _cached = list;
            return list;
        }
        public static void Refresh()
        {
            _cached = null;
            _all_cached = null;
            _ = List(true);
        }

        public static void Disabled(string name)
        {
            string cache_key = $"cache:pdd_pool:{name}:disabled";
            long count = RedisHelper.IncrBy(cache_key);
            RedisHelper.Expire(cache_key, 10);
            if (count > 1) return;

            new DBContext.Table("pdd_pool")
                .Add("status", 0)
                .Where("name=@name", new { name })
                .Update();
            _ = List(true);

            NotifyCore.Notify(new NifyMessage
            {
                message = $"【多多:{name}】调用异常",
                priority = NifyMessagePriority.high,
                tags = ["red_circle"]
            });
        }


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

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

            _ = List(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);
        }

        internal static void AccountExhausted()
        {
            string cache_key = $"cache:pdd_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("没账号", $"【多多】没有匹配账号");
        }

        internal static async Task<JsonElement> GetUserInfo(string cookies)
        {
            JsonElement result = default;
            try
            {
                string url = "https://jinbao.pinduoduo.com/network/api/account/userInfo";
                WebClientUtility client = new WebClientUtility();
                client.Post("{}");
                client.SetCookies(cookies);
                client.SetContentType("application/json");
                var response = await client.RequestAsync(url, "POST");
                var body = response.Body();
                result = body.Convert2JsonElement();
            }
            catch (Exception ex)
            {
            }
            return result;
        }

        public static async Task<int> UpdateCookies(string cookies, string user_agent, int id = 0)
        {
            if (string.IsNullOrEmpty(cookies)) return 0;
            var userinfo = await GetUserInfo(cookies);
            if (userinfo.ValueKind != JsonValueKind.Object) return 0;

            int duoId = userinfo.PathRead<int>("result.duoId", 0);
            string company = userinfo.PathRead<string>("result.mobile", string.Empty);
            string lastPid = userinfo.PathRead<string>("result.lastPid", string.Empty);

            int accountId = 0;
            if (duoId == 0 && id == 0) return 0;


            string filter = id != 0 ? "id=@id" : "duoId=@duoId";
            var exist = new DBContext.Table("pdd_pool").Get<PddPoolDTO>(filter, new { id, duoId });
            if (exist != null)
            {
                var status = exist.status;
                var work_mode = exist.work_mode;
                accountId = exist.id;
                if (work_mode == PddUnionWorkMode.Crawler) status = true;
                new DBContext.Table("pdd_pool")
                    .Add("cookies", cookies)
                    .Add("user_agent", user_agent)
                    .Add("status", status)
                    .Add("cookie_status", 1)
                    .Add("last_time", DateTime.Now)
                    .Add("login_time", DateTime.Now)
                    .Where("id=@id", new { exist.id })
                    .Update();
                if (status) _ = List(true);
            }
            else
            {
                accountId = new DBContext.Table("pdd_pool")
                    .Add("duoId", duoId)
                    .Add("name", company)
                    .Add("company", company)
                    .Add("description", "由cookies上报创建此记录")
                    .Add("cookies", cookies)
                    .Add("user_agent", user_agent)
                    .Add("pid", lastPid)
                    .Add("cookie_status", 1)
                    .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;
        }


        public static int CookieDisabled(int id)
        {
            return new DBContext.Table("pdd_pool")
                .Add("cookie_status", 0)
                .Add("last_time", DateTime.Now)
                .Where("id=@id", new { id })
                .Update();
        }


        public static int Update(PddPoolDTO account)
        {
            return new DBContext.Table("pdd_pool")
                .Add("current_hourly_calls", account.current_hourly_calls)
                .Add("current_daily_calls", account.current_daily_calls)

                //.Add("today_clickNum", account.today_clickNum)
                //.Add("today_cosFee", account.today_cosFee)
                //.Add("today_cosPrice", account.today_cosPrice)
                //.Add("today_finishCosFee", account.today_finishCosFee)
                //.Add("today_finishCosPrice", account.today_finishCosPrice)
                //.Add("today_finishOrderNum", account.today_finishOrderNum)
                //.Add("today_orderNum", account.today_orderNum)
                .Add("last_time", DateTime.Now)
                .Where("id=@id", new { account.id })
                .Update();
        }
    }
}