dotnet/molilian.core/Core/taoke/TkLogCore.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 static dodohold.core.ZTOExpress.CreateOrderArgs;
using System.Net;
using System.Security.Cryptography;
using Spire.Pdf.Exporting.XPS.Schema;
using System.Xml.Linq;
using static QRCoder.PayloadGenerator;


namespace molilian.core
{
    public class TkLogCore
    {
        static string queue_tb_key = "queue:logs:tb";
        static string queue_jd_key = "queue:logs:jd";

        static string queue_parse_tb_key = "queue:parse_logs:tb";
        static string queue_parse_jd_key = "queue:parse_logs:jd";
        static string queue_parse_dy_key = "queue:parse_logs:dy";
        static string queue_parse_tool_key = "queue:parse_logs:tool";


        public static void BatchInsertLogDB()
        {
            using var connection = DBContext.GetOpenConnection();
            connection.Open();
            using var transaction = connection.BeginTransaction();
            try
            {
                for (int i = 0; i < 100; i++)
                {
                    var data = RedisHelper.LPop<TkDataDTO>(queue_tb_key);
                    if (data == null) break;

                    new DBContext.Table(connection, "tk_logs")
                        .Add("channel", (int)data.channel)
                        .Add("accountName", data.accountName)
                        .Add("rawContent", data.rawContent)
                        .Add("rawContent2", data.rawContent2)
                        .Add("success", data.success)
                        .Add("message", data.message)
                        .Add("reason", data.reason)
                        .Add("content", data.content)
                        .Add("couponAmount", data.couponAmount)
                        .Add("itemId", data.itemId)
                        .Add("itemName", data.itemName)
                        .Add("pic", data.pic)
                        .Add("promotionPrice", data.promotionPrice)
                        .Add("taoToken", data.taoToken)
                        .Add("shortLinkurl", data.shortLinkurl)
                        .Add("deeplink_url", data.deeplink_url)
                        .Add("num_iid", data.num_iid)
                        .Add("elapsedTime", data.elapsedTime)
                        .Add("ip", data.ip)
                        .Add("oaid", data.oaid)
                        .Add("create_time", data.create_time)
                        .Create(DBContext.InsertType.NORMAL, transaction);
                }

                for (int i = 0; i < 100; i++)
                {
                    var data = RedisHelper.LPop<JdDataDTO>(queue_jd_key);
                    if (data == null) break;

                    new DBContext.Table(connection, "tk_logs")
                        .Add("channel", (int)data.channel)
                        .Add("accountName", data.accountName)
                        .Add("rawContent", data.rawContent)
                        .Add("rawContent2", data.rawContent2)
                        .Add("success", data.success)
                        .Add("message", data.message)
                        .Add("reason", data.reason)
                        .Add("shortLinkurl", data.shortLinkurl)
                        .Add("deeplink_url", data.deeplink_url)
                        .Add("elapsedTime", data.elapsedTime)
                        .Add("ip", data.ip)
                        .Add("oaid", data.oaid)
                        .Add("create_time", data.create_time)
                        .Create(DBContext.InsertType.NORMAL, transaction);
                }

                for (int i = 0; i < 100; i++)
                {
                    var data = RedisHelper.LPop<TkDataDTO>(queue_parse_tb_key);
                    if (data == null) break;

                    new DBContext.Table(connection, "tk_parse_logs")
                        .Add("channel", (int)data.channel)
                        .Add("accountName", data.accountName)
                        .Add("rawContent", data.rawContent)
                        .Add("success", data.success)
                        .Add("message", data.message)
                        .Add("reason", data.reason)
                        .Add("content", data.content)
                        .Add("itemId", data.itemId)
                        .Add("itemName", data.itemName)
                        .Add("pic", data.pic)
                        .Add("couponAmount", data.couponAmount)
                        .Add("promotionPrice", data.promotionPrice)
                        .Add("taoToken", data.taoToken)
                        .Add("shortLinkurl", data.shortLinkurl)
                        .Add("deeplink_url", data.deeplink_url)
                        .Add("num_iid", data.num_iid)
                        .Add("elapsedTime", data.elapsedTime)
                        .Add("ip", data.ip)
                        .Add("oaid", data.oaid)
                        .Add("create_time", data.create_time)
                        .Create(DBContext.InsertType.NORMAL, transaction);
                }

                for (int i = 0; i < 100; i++)
                {
                    var data = RedisHelper.LPop<JdDataDTO>(queue_parse_jd_key);
                    if (data == null) break;

                    new DBContext.Table(connection, "tk_parse_logs")
                        .Add("channel", (int)data.channel)
                        .Add("accountName", data.accountName)
                        .Add("rawContent", data.rawContent)
                        .Add("success", data.success)
                        .Add("message", data.message)
                        .Add("reason", data.reason)
                        .Add("content", data.content)
                        .Add("itemId", data.itemId)
                        .Add("itemName", data.itemName)
                        .Add("pic", data.pic)
                        .Add("couponAmount", data.couponAmount)
                        .Add("promotionPrice", data.promotionPrice)
                        .Add("taoToken", data.taoToken)
                        .Add("shortLinkurl", data.shortLinkurl)
                        .Add("deeplink_url", data.deeplink_url)
                        .Add("elapsedTime", data.elapsedTime)
                        .Add("ip", data.ip)
                        .Add("oaid", data.oaid)
                        .Add("create_time", data.create_time)
                        .Create(DBContext.InsertType.NORMAL, transaction);
                }
                for (int i = 0; i < 100; i++)
                {
                    var data = RedisHelper.LPop<DyDataDTO>(queue_parse_dy_key);
                    if (data == null) break;

                    new DBContext.Table(connection, "tk_parse_logs")
                        .Add("channel", (int)data.channel)
                        .Add("accountName", data.accountName)
                        .Add("rawContent", data.rawContent)
                        .Add("success", data.success)
                        .Add("message", data.message)
                        .Add("reason", data.reason)
                        .Add("content", data.content)
                        .Add("itemId", data.itemId)
                        .Add("itemName", data.itemName)
                        .Add("pic", data.pic)
                        .Add("couponAmount", data.couponAmount)
                        .Add("promotionPrice", data.promotionPrice)
                        .Add("taoToken", data.taoToken)
                        .Add("shortLinkurl", data.shortLinkurl)
                        .Add("deeplink_url", data.deeplink_url)
                        .Add("elapsedTime", data.elapsedTime)
                        .Add("ip", data.ip)
                        .Add("oaid", data.oaid)
                        .Add("create_time", data.create_time)
                        .Create(DBContext.InsertType.NORMAL, transaction);
                }
                for (int i = 0; i < 100; i++)
                {
                    var data = RedisHelper.LPop<ToolParseDataDTO>(queue_parse_tool_key);
                    if (data == null) break;

                    new DBContext.Table(connection, "tool_parse_logs")
                        .Add("channel", (int)data.channel)
                        .Add("rawContent", data.rawContent)
                        .Add("success", data.success)
                        .Add("message", data.message)
                        .Add("reason", data.reason)
                        .Add("content", data.content)
                        .Add("taoToken", data.taoToken)
                        .Add("shortLinkurl", data.shortLinkurl)
                        .Add("deeplink_url", data.deeplink_url)
                        .Add("elapsedTime", data.elapsedTime)
                        .Add("ip", data.ip)
                        .Add("oaid", data.oaid)
                        .Add("create_time", data.create_time)
                        .Create(DBContext.InsertType.NORMAL, transaction);
                }
                transaction.Commit();
            }
            catch (Exception ex)
            {
                transaction.Rollback();

                new LoggerLibrary("database_error", "parse_log")
                    .Info(ex.Message, ex.StackTrace)
                    .Save();

                NotifyCore.Notify(new NifyMessage
                {
                    message = $"【写入日志异常】\n{ex.Message}\n{ex.StackTrace}",
                    priority = NifyMessagePriority.high,
                    tags = ["red_circle"]
                });
            }
            finally
            {
                connection.Close();
            }
        }

        public static async Task LogAsync(JdDataDTO response)
        {
            try
            {
                var ts = DateTime.Now - response.create_time;
                response.elapsedTime = (int)ts.TotalMilliseconds;
                RedisHelper.RPush(queue_jd_key, response);
                saveCache(response.channel.ToString(), response.accountName, response.success, response.message, response.reason);
            }
            catch (Exception ex) { }
        }

        public static async Task LogAsync(TkDataDTO response, AlimamaPlus? alimamaPlus = null)
        {
            try
            {
                var ts = DateTime.Now - response.create_time;
                response.elapsedTime = (int)ts.TotalMilliseconds;
                RedisHelper.RPush(queue_tb_key, response);
                saveCache(response.channel.ToString(), response.accountName, response.success, response.message, response.reason);

                if (!response.success && "nologin".Equals(response.message))
                {
                    switch (response.channel)
                    {
                        case TkChannelEnum.tb:

                            await Task.Run(() =>
                            {
                                if (alimamaPlus != null)
                                {
                                    (bool success, string message) = alimamaPlus.RenewCookie();
                                    if (success) return;
                                }
                                TkPoolCore.Disabled(response.accountName, $"{response.rawContent}\n{response.rawContent2}");
                            });
                            break;
                    }
                }
                if ("没有匹配账号".Equals(response.reason))
                {
                    TkPoolCore.AccountExhausted();
                }
            }
            catch (Exception ex)
            {
                new LoggerLibrary("unionParse", "database_error")
                .Info(response.rawContent, response.rawContent2)
                .Info(response.Convert2Json())
                .Info(ex.Message, ex.StackTrace)
                .Save();
            }
        }

        public static async Task ParseLogAsync(TkDataDTO response, AlimamaPlus? alimamaPlus = null)
        {
            try
            {
                var ts = DateTime.Now - response.create_time;
                response.elapsedTime = (int)ts.TotalMilliseconds;
                RedisHelper.RPush(queue_parse_tb_key, response);
                saveCache(response.channel.ToString(), response.accountName, response.success, response.message, response.reason);

                if (!response.success && "nologin".Equals(response.message))
                {
                    switch (response.channel)
                    {
                        case TkChannelEnum.tb:
                            await Task.Run(() =>
                            {
                                if (alimamaPlus != null)
                                {
                                    (bool success, string message) = alimamaPlus.RenewCookie();
                                    if (success) return;
                                }
                                TkPoolCore.Disabled(response.accountName, $"{response.rawContent}");
                            }); break;
                    }
                }
            }
            catch (Exception ex)
            {
                new LoggerLibrary("unionParse", "database_error")
                .Info(response.rawContent)
                .Info(response.Convert2Json())
                .Info(ex.Message, ex.StackTrace)
                .Save();
            }
        }
        public static async Task ParseLogAsync(JdDataDTO response)
        {
            try
            {
                var ts = DateTime.Now - response.create_time;
                response.elapsedTime = (int)ts.TotalMilliseconds;
                RedisHelper.RPush(queue_parse_jd_key, response);
                saveCache(response.channel.ToString(), response.accountName, response.success, response.message, response.reason);

            }
            catch (Exception ex) { }
        }
        public static async Task ParseLogAsync(DyDataDTO response)
        {
            try
            {
                var ts = DateTime.Now - response.create_time;
                response.elapsedTime = (int)ts.TotalMilliseconds;
                RedisHelper.RPush(queue_parse_dy_key, response);
                saveCache(response.channel.ToString(), response.accountName, response.success, response.message, response.reason);

            }
            catch (Exception ex) { }
        }
        public static async Task ParseLogAsync(ToolParseDataDTO response)
        {
            try
            {
                var ts = DateTime.Now - response.create_time;
                response.elapsedTime = (int)ts.TotalMilliseconds;
                RedisHelper.RPush(queue_parse_tool_key, response);
                saveCache(response.channel.ToString(), "tool", response.success, response.message, response.reason);
            }
            catch (Exception ex) { }
        }


        public static async Task Log2(JdDataDTO response)
        {
            await Task.Run(() =>
            {
                try
                {
                    new DBContext.Table("tk_logs")
                    .Add("channel", (int)response.channel)
                    .Add("accountName", response.accountName)
                    .Add("rawContent", response.rawContent)
                    .Add("rawContent2", response.rawContent2)
                    .Add("ip", response.ip)
                    .Add("oaid", response.oaid)
                    .Add("success", response.success)
                    .Add("message", response.message)
                    .Add("reason", response.reason)
                    .Add("shortLinkurl", response.shortLinkurl)
                    .Add("deeplink_url", response.deeplink_url)
                    .Add("ip", response.ip)
                    .Add("oaid", response.oaid)
                    .Add("create_time", response.create_time)
                    .Add("elapsedTime", response.elapsedTime)
                    .Create();

                }
                catch (Exception ex)
                {
                    new LoggerLibrary("database_error")
                    .Info(response.rawContent, response.rawContent2)
                    .Info(response.Convert2Json())
                    .Info(ex.Message, ex.StackTrace)
                    .Save();
                }
            });
        }

        public static async Task Log2(TkDataDTO response, AlimamaPlus? alimamaPlus = null)
        {
            await Task.Run(() =>
            {
                try
                {
                    new DBContext.Table("tk_logs")
                    .Add("channel", (int)response.channel)
                    .Add("accountName", response.accountName)
                    .Add("rawContent", response.rawContent)
                    .Add("rawContent2", response.rawContent2)
                    .Add("success", response.success)
                    .Add("message", response.message)
                    .Add("reason", response.reason)
                    .Add("content", response.content)
                    .Add("couponAmount", response.couponAmount)
                    .Add("taoToken", response.taoToken)
                    .Add("shortLinkurl", response.shortLinkurl)
                    .Add("deeplink_url", response.deeplink_url)
                    .Add("num_iid", response.num_iid)
                    .Add("elapsedTime", response.elapsedTime)
                    .Add("ip", response.ip)
                    .Add("oaid", response.oaid)
                    .Add("create_time", response.create_time)
                    .Create();

                    if (!response.success && "nologin".Equals(response.message))
                    {
                        switch (response.channel)
                        {
                            case TkChannelEnum.tb:
                                if (alimamaPlus != null)
                                {
                                    (bool success, string message) = alimamaPlus.RenewCookie();
                                    if (success) return;
                                }
                                TkPoolCore.Disabled(response.accountName, $"{response.rawContent}\n{response.rawContent2}");
                                break;
                                //case TkChannelEnum.jdUnion:
                                //    VeapiPoolCore.Disabled(response.accountName);
                                //    break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    new LoggerLibrary("database_error")
                    .Info(response.rawContent, response.rawContent2)
                    .Info(response.Convert2Json())
                    .Info(ex.Message, ex.StackTrace)
                    .Save();
                }
            });
        }


        public static async Task ParseLog2(TkDataDTO response, AlimamaPlus? alimamaPlus = null)
        {
            await Task.Run(() =>
            {
                try
                {
                    new DBContext.Table("tk_parse_logs")
                    .Add("channel", (int)response.channel)
                    .Add("accountName", response.accountName)
                    .Add("rawContent", response.rawContent)
                    .Add("success", response.success)
                    .Add("message", response.message)
                    .Add("reason", response.reason)
                    .Add("content", response.content)
                    .Add("couponAmount", response.couponAmount)
                    .Add("taoToken", response.taoToken)
                    .Add("shortLinkurl", response.shortLinkurl)
                    .Add("deeplink_url", response.deeplink_url)
                    .Add("num_iid", response.num_iid)
                    .Add("elapsedTime", response.elapsedTime)
                    .Add("ip", response.ip)
                    .Add("oaid", response.oaid)
                    .Add("create_time", response.create_time)
                    .Create();

                    if (!response.success && "nologin".Equals(response.message))
                    {
                        switch (response.channel)
                        {
                            case TkChannelEnum.tb:
                                if (alimamaPlus != null)
                                {
                                    (bool success, string message) = alimamaPlus.RenewCookie();
                                    if (success) return;
                                }
                                TkPoolCore.Disabled(response.accountName, $"{response.rawContent}");
                                break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    new LoggerLibrary("unionParse", "database_error")
                    .Info(response.rawContent)
                    .Info(response.Convert2Json())
                    .Info(ex.Message, ex.StackTrace)
                    .Save();
                }
            });
        }
        public static async Task ParseLog2(JdDataDTO response)
        {
            await Task.Run(() =>
            {
                try
                {
                    new DBContext.Table("tk_parse_logs")
                    .Add("channel", (int)response.channel)
                    .Add("accountName", response.accountName)
                    .Add("rawContent", response.rawContent)
                    .Add("success", response.success)
                    .Add("message", response.message)
                    .Add("reason", response.reason)
                    .Add("content", response.content)
                    .Add("shortLinkurl", response.shortLinkurl)
                    .Add("deeplink_url", response.deeplink_url)
                    .Add("elapsedTime", response.elapsedTime)
                    .Add("ip", response.ip)
                    .Add("oaid", response.oaid)
                    .Add("create_time", response.create_time)
                    .Create();
                }
                catch (Exception ex)
                {
                    new LoggerLibrary("unionParse", "database_error")
                    .Info(response.rawContent)
                    .Info(response.Convert2Json())
                    .Info(ex.Message, ex.StackTrace)
                    .Save();
                }
            });
        }


        private static void saveCache(string channel, string accountName, bool success, string message, string reason)
        {
            saveAccountCache("all", success, message, reason);
            saveAccountCache($"{channel}", success, message, reason);
            saveAccountCache($"{accountName}", success, message, reason);

        }

        private static void saveAccountCache(string accountName, bool success, string message, string reason)
        {
            RedisHelper.IncrBy($":total:{accountName}:{DateTime.Now:yyyyMM}");
            RedisHelper.IncrBy($":total:{accountName}:{DateTime.Now:yyyyMMdd}");
            RedisHelper.IncrBy($":total:{accountName}:{DateTime.Now:yyyyMMddHH}");


            string result = success ? "success" : "fail";
            RedisHelper.IncrBy($":total:{accountName}:{result}:{DateTime.Now:yyyyMM}");
            RedisHelper.IncrBy($":total:{accountName}:{result}:{DateTime.Now:yyyyMMdd}");
            RedisHelper.IncrBy($":total:{accountName}:{result}:{DateTime.Now:yyyyMMddHH}");


            if (!string.IsNullOrEmpty(message))
            {
                RedisHelper.SAdd($":total:{accountName}:message:{DateTime.Now:yyyyMM}", message);
                RedisHelper.SAdd($":total:{accountName}:message:{DateTime.Now:yyyyMMdd}", message);
                RedisHelper.SAdd($":total:{accountName}:message:{DateTime.Now:yyyyMMddHH}", message);

                RedisHelper.IncrBy($":total:{accountName}:{message}:{DateTime.Now:yyyyMM}");
                RedisHelper.IncrBy($":total:{accountName}:{message}:{DateTime.Now:yyyyMMdd}");
                RedisHelper.IncrBy($":total:{accountName}:{message}:{DateTime.Now:yyyyMMddHH}");
            }

            if (!string.IsNullOrEmpty(reason))
            {
                RedisHelper.SAdd($":total:{accountName}:reason:{DateTime.Now:yyyyMM}", reason);
                RedisHelper.SAdd($":total:{accountName}:reason:{DateTime.Now:yyyyMMdd}", reason);
                RedisHelper.SAdd($":total:{accountName}:reason:{DateTime.Now:yyyyMMddHH}", reason);

                RedisHelper.IncrBy($":total:{accountName}:{reason}:{DateTime.Now:yyyyMM}");
                RedisHelper.IncrBy($":total:{accountName}:{reason}:{DateTime.Now:yyyyMMdd}");
                RedisHelper.IncrBy($":total:{accountName}:{reason}:{DateTime.Now:yyyyMMddHH}");
            }

        }
    }

}