Compare commits

...
Author SHA1 Message Date
chfei 86ee692a04 跟新 未命中云数据记录 2026-11-02 09:30:42 +08:00
chfei 53a4887d35 云商品库 增加违规记录和违规字典 2026-10-30 14:22:44 +08:00
chfei d0f9f00b76 增加ImageCache微信 图片缓存 2026-10-21 17:04:26 +08:00
chfei d6cb5b966b 移除Nlog 2026-10-15 17:15:27 +08:00
chfei fdc9b9e36d 修改日志框架 2026-10-15 17:15:10 +08:00
chfei f1fa0401c2 修复用户收藏查询bug 2026-10-15 17:14:52 +08:00
chfei 08757d15e4 更新 云仓商品库 2026-10-14 17:33:37 +08:00
chfei ecba3b7ee6 修改 Apiresult 的返回 Success->ok 2026-10-14 12:04:58 +08:00
chfei db4f030c17 修改代码
增加云商品数据
2026-10-14 11:53:36 +08:00
102 changed files with 5036 additions and 359 deletions

No files matched your search

+13 -19
View File
@@ -16,37 +16,31 @@ namespace MAX.Framework.Commons
{ {
if (context.Result is ObjectResult objResult) if (context.Result is ObjectResult objResult)
{ {
if (!IsAlreadyWrapped(objResult.Value)) if (objResult.Value is ApiResultBase)
{ {
var apiResult = ApiResult<object>.Success(objResult.Value); objResult.StatusCode = 200;
objResult.DeclaredType = objResult.Value.GetType();
return;
}
// 非成功响应交由状态码中间件处理,避免先包装成业务成功。
var statusCode = objResult.StatusCode ?? 200;
if (statusCode >= 200 && statusCode < 300)
{
var apiResult = ApiResult<object>.Ok(objResult.Value);
objResult.Value = apiResult; objResult.Value = apiResult;
objResult.DeclaredType = null; objResult.DeclaredType = null;
objResult.StatusCode = 200;
} }
} }
else if (context.Result is EmptyResult || context.Result is NoContentResult) else if (context.Result is EmptyResult || context.Result is NoContentResult)
{ {
context.Result = new ObjectResult(ApiResult.Success()); context.Result = new ObjectResult(ApiResult.Ok()) { StatusCode = 200 };
} }
} }
public void OnActionExecuting(ActionExecutingContext context) { } public void OnActionExecuting(ActionExecutingContext context) { }
private static bool IsAlreadyWrapped(object? value)
{
if (value is null) return false;
var type = value.GetType();
// 递归判断:只要类型链上有任何一层是 ApiResult<> 的开放泛型定义,或直接是 ApiResult,就算已包装
while (type is not null)
{
if (type == typeof(ApiResult)) return true;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ApiResult<>)) return true;
type = type.BaseType;
}
return false;
}
} }
} }
@@ -0,0 +1,188 @@
using MAX.Framework.Dtos;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Microsoft.IO;
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.Json;
namespace MAX.Framework.Commons
{
/// <summary>
/// 统一状态码中间件
/// 统一返回200 固定格式
/// </summary>
internal class UnifyStatusCodeMiddleware
{
private readonly RequestDelegate _next;
private readonly ILogger<UnifyStatusCodeMiddleware> _logger;
// 静态复用,全局唯一的内存池管理器
private static readonly RecyclableMemoryStreamManager _streamManager = new();
// 需要直接透传、不做缓冲的 Content-Type 前缀
private static readonly string[] _passthroughPrefixes =
{
"image/",
"audio/",
"video/",
"application/octet-stream",
"application/zip",
"application/pdf",
"application/x-msdownload",
"text/event-stream"
};
public UnifyStatusCodeMiddleware(RequestDelegate next, ILogger<UnifyStatusCodeMiddleware> logger)
{
_next = next;
_logger = logger;
}
public async Task InvokeAsync(HttpContext context)
{
// 1. 只处理 /api 路径(按需调整或删除)
if (!context.Request.Path.StartsWithSegments("/api"))
{
await _next(context);
return;
}
// 2. 二进制 / 流式响应:不缓冲,直接透传
var accept = context.Request.Headers.Accept.ToString();
if (IsPassthroughByRequest(context) || IsPassthroughByAccept(accept))
{
await _next(context);
return;
}
var originalBody = context.Response.Body;
using var buffer = _streamManager.GetStream();
context.Response.Body = buffer;
try
{
await _next(context);
}
catch (Exception ex)
{
// 兜底:Filter 没抓到的异常
_logger.LogError(ex, "未处理异常: {Path}", context.Request.Path);
// 清空已写入的内容,准备返回 500 统一格式
buffer.SetLength(0);
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
}
var statusCode = context.Response.StatusCode;
var contentType = context.Response.ContentType ?? string.Empty;
// 3. 响应体如果本身就是二进制/流式,透传不处理
if (IsPassthroughByResponseContentType(contentType))
{
buffer.Position = 0;
context.Response.Body = originalBody;
await buffer.CopyToAsync(originalBody);
return;
}
// 4. 2xx 且已有响应体:透传(已被 UnifyResultFilter 包装过,不再包一层)
if (statusCode >= 200 && statusCode < 300 && buffer.Length > 0)
{
buffer.Position = 0;
context.Response.Body = originalBody;
await buffer.CopyToAsync(originalBody);
return;
}
// 5. 非 2xx:统一改写为 200 + ApiResult
var (code, msg) = MapStatusCode(statusCode);
// 如果是 2xx 但响应体为空(少见,例如 204),也当作成功
if (statusCode >= 200 && statusCode < 300)
{
code = (int)ResultCode.Success;
msg = "success";
}
var result = statusCode >= 200 && statusCode < 300
? ApiResult.Ok()
: ApiResult.Fail(msg, code);
// 恢复原始流并写出
context.Response.Body = originalBody;
context.Response.StatusCode = StatusCodes.Status200OK;
context.Response.ContentType = "application/json; charset=utf-8";
context.Response.ContentLength = null;
// 清理可能存在的旧响应头
context.Response.Headers.Remove("WWW-Authenticate");
await context.Response.WriteAsJsonAsync(result, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
}
private static bool IsPassthroughByRequest(HttpContext context)
{
// 上传大文件等场景,请求体大,避免缓冲
var contentLength = context.Request.ContentLength;
if (contentLength.HasValue && contentLength.Value > 1_000_000) // >1MB
{
return true;
}
// Range 请求(断点续传)不缓冲
if (context.Request.Headers.ContainsKey("Range"))
{
return true;
}
return false;
}
private static bool IsPassthroughByAccept(string accept)
{
if (string.IsNullOrEmpty(accept)) return false;
foreach (var prefix in _passthroughPrefixes)
{
if (accept.Contains(prefix, StringComparison.OrdinalIgnoreCase))
return true;
}
return false;
}
private static bool IsPassthroughByResponseContentType(string contentType)
{
if (string.IsNullOrEmpty(contentType)) return false;
foreach (var prefix in _passthroughPrefixes)
{
if (contentType.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
return true;
}
return false;
}
private static (int code, string msg) MapStatusCode(int statusCode) => statusCode switch
{
400 => ((int)ResultCode.ValidationError, "请求参数错误"),
401 => ((int)ResultCode.Unauthorized, "未授权,请先登录"),
403 => ((int)ResultCode.Forbidden, "禁止访问"),
404 => ((int)ResultCode.NotFound, "资源不存在"),
405 => ((int)ResultCode.Fail, "请求方法不允许"),
429 => ((int)ResultCode.Fail, "请求过于频繁"),
500 => ((int)ResultCode.ServerError, "服务器内部错误"),
502 => ((int)ResultCode.ServerError, "网关错误"),
503 => ((int)ResultCode.ServerError, "服务暂不可用"),
504 => ((int)ResultCode.ServerError, "网关超时"),
_ => ((int)ResultCode.Fail, $"请求失败({statusCode})")
};
}
}
@@ -1,22 +1,75 @@
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using NLog.Web; using Serilog;
using System; using Serilog.Debugging;
using System.Collections.Generic;
using System.Text;
namespace MAX.Framework.DependencyInjection namespace MAX.Framework.DependencyInjection
{ {
/// <summary>
/// Serilog 日志接入:读取 appsettings.Serilog.json(文件缺失时回退到主配置里的 Serilog 节点),
/// 再把 Serilog 接入 ASP.NET Core 日志管线,使 ILogger&lt;T&gt; 与 Log 静态入口共用同一套 Sink。
/// 日志按等级分目录(logs/等级/日期.log)由 appsettings.Serilog.json 里的 File sink + rollingInterval 负责。
/// </summary>
public static class LoggerExtensions public static class LoggerExtensions
{ {
public static WebApplicationBuilder AddLogger(this WebApplicationBuilder builder) /// <summary>Serilog 独立配置文件(构建/发布会复制到输出目录)。</summary>
private const string ConfigurationFileName = "appsettings.Serilog.json";
public static IHostApplicationBuilder AddLogger(this IHostApplicationBuilder host)
{ {
builder.Logging.ClearProviders(); IConfigurationManager configuration = host.Configuration;
//builder.Logging.SetMinimumLevel(LogLevel.Information);
builder.Host.UseNLog(); // Serilog 默认会静默吞掉配置错误(Sink 名写错、过滤器语法错误等),
return builder; // 开发环境把自诊断信息输出到控制台,避免再出现「配置了却没有日志」却查不到原因。
if (host.Environment.IsDevelopment())
{
SelfLog.Enable(Console.Error.WriteLine);
}
string? configurationPath = ResolveConfigurationPath(host);
if (configurationPath is null)
{
// 不直接抛异常:允许把 Serilog 节点写进 appsettings.json,但必须显式提示,而不是静默降级成「无任何 Sink」。
Console.Error.WriteLine($"[Serilog] 未找到 {ConfigurationFileName},将使用主配置中的 Serilog 节点。");
}
else
{
configuration.AddJsonFile(configurationPath, optional: false, reloadOnChange: true);
}
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(configuration)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
// 接管 ASP.NET Core 日志管线:宿主日志与 ILogger<T> 统一写入 Log.Logger;
// dispose: true 让宿主停止时自动 CloseAndFlush,保证缓冲中的日志落盘。
host.Services.AddSerilog(Log.Logger, dispose: true);
return host;
}
/// <summary>
/// 定位 Serilog 配置文件:支持绝对路径,其余情况依次在内容根目录(开发时即项目目录)与程序输出目录中查找。
/// </summary>
private static string? ResolveConfigurationPath(IHostApplicationBuilder host)
{
if (Path.IsPathRooted(ConfigurationFileName))
{
return File.Exists(ConfigurationFileName) ? ConfigurationFileName : null;
}
string[] candidates =
[
Path.Combine(host.Environment.ContentRootPath, ConfigurationFileName),
Path.Combine(AppContext.BaseDirectory, ConfigurationFileName),
];
return candidates.FirstOrDefault(File.Exists);
} }
} }
} }
@@ -1,5 +1,6 @@
using MAX.Core.DependencyInjection; using MAX.Core.DependencyInjection;
using MAX.Core.Interfaces; using MAX.Core.Interfaces;
using MAX.Core.Logger;
using MAX.Framework.Commons; using MAX.Framework.Commons;
using MAX.Framework.Dtos; using MAX.Framework.Dtos;
using MAX.Framework.Interfaces; using MAX.Framework.Interfaces;
@@ -32,6 +33,9 @@ namespace MAX.Framework.DependencyInjection
/// </summary> /// </summary>
public static IServiceCollection AddStore(this IHostApplicationBuilder host) public static IServiceCollection AddStore(this IHostApplicationBuilder host)
{ {
host.AddLogger();
//host.Services.AddSingleton<ILoggerFacade>(NLogger.Instance);//注册log
IEnumerable<Assembly> assemblies = GetApplicationAssemblies(); IEnumerable<Assembly> assemblies = GetApplicationAssemblies();
// 同一个类可能同时实现 IStartup 与 IModule,这里缓存实例,保证两个阶段拿到的是同一个对象 // 同一个类可能同时实现 IStartup 与 IModule,这里缓存实例,保证两个阶段拿到的是同一个对象
Dictionary<Type, object> instances = []; Dictionary<Type, object> instances = [];
@@ -211,6 +215,7 @@ namespace MAX.Framework.DependencyInjection
public static IApplicationBuilder UseStore(this IApplicationBuilder app) public static IApplicationBuilder UseStore(this IApplicationBuilder app)
{ {
app.UseMiddleware<UnifyStatusCodeMiddleware>();
foreach (IStartup startup in Startups) foreach (IStartup startup in Startups)
{ {
startup.Start((app as IHost).Services); startup.Start((app as IHost).Services);
+43 -11
View File
@@ -1,5 +1,4 @@
using MAX.Framework.Commons; using System.Text.Json.Serialization;
using static System.Runtime.InteropServices.JavaScript.JSType;
namespace MAX.Framework.Dtos namespace MAX.Framework.Dtos
{ {
@@ -30,10 +29,10 @@ namespace MAX.Framework.Dtos
public abstract class ApiResultBase public abstract class ApiResultBase
{ {
/// <summary>业务状态码</summary> /// <summary>业务状态码</summary>
public int Code { get; set; } = ResultCode.Success; public int Code { get; init; } = ResultCode.Success;
/// <summary>提示信息</summary> /// <summary>提示信息</summary>
public string? Msg { get; set; } public string? Msg { get; init; }
/// <summary>请求是否成功</summary> /// <summary>请求是否成功</summary>
public bool Success => Code == ResultCode.Success; public bool Success => Code == ResultCode.Success;
@@ -45,25 +44,58 @@ namespace MAX.Framework.Dtos
/// </summary> /// </summary>
public class ApiResult<T> : ApiResultBase public class ApiResult<T> : ApiResultBase
{ {
public T? Data { get; set; } /// <summary>响应数据;失败时不应依赖该值,值类型默认值并非 null。</summary>
[JsonIgnore(Condition = JsonIgnoreCondition.Never)]
public T? Data { get; init; }
public static ApiResult<T> Success(T data, string msg = "操作成功") /// <summary>将无数据响应转换为当前数据类型,保留状态码和提示信息。</summary>
public static implicit operator ApiResult<T>(ApiResult result)
{
ArgumentNullException.ThrowIfNull(result);
return new ApiResult<T> { Code = result.Code, Msg = result.Msg, Data = default };
}
public static ApiResult<T> Ok(T data, string msg = "操作成功")
=> new ApiResult<T> { Code = ResultCode.Success, Data = data, Msg = msg }; => new ApiResult<T> { Code = ResultCode.Success, Data = data, Msg = msg };
public static ApiResult<T> Fail(string msg = "操作失败", int code = ResultCode.Fail, T? data = default) public static ApiResult<T> Fail(string msg = "操作失败", int code = ResultCode.Fail, T? data = default)
=> new ApiResult<T> { Code = code, Msg = msg, Data = data }; {
ApiResult.ValidateFailureCode(code);
return new ApiResult<T> { Code = code, Msg = msg, Data = data };
}
} }
/// <summary> /// <summary>
/// 响应 /// 响应
/// </summary> /// </summary>
public class ApiResult : ApiResult<object> public class ApiResult : ApiResultBase
{ {
public static ApiResult Success(string msg = "操作成功") /// <summary>无数据响应仍输出 data: null,保持统一的响应字段。</summary>
=> new ApiResult { Code = ResultCode.Success, Msg = msg }; [JsonIgnore(Condition = JsonIgnoreCondition.Never)]
public object? Data => null;
/// <summary>创建带数据的成功响应,自动推断数据类型。</summary>
public static ApiResult<T> Ok<T>(T data, string msg = "操作成功")
=> ApiResult<T>.Ok(data, msg);
/// <summary>创建带数据的失败响应,自动推断数据类型。</summary>
public static ApiResult<T> Fail<T>(string msg, T data, int code = ResultCode.Fail)
=> ApiResult<T>.Fail(msg, code, data);
public static ApiResult Ok()
=> new ApiResult { Code = ResultCode.Success, Msg = "操作成功" };
public static ApiResult Fail(string msg = "操作失败", int code = ResultCode.Fail) public static ApiResult Fail(string msg = "操作失败", int code = ResultCode.Fail)
=> new ApiResult { Code = code, Msg = msg }; {
ValidateFailureCode(code);
return new ApiResult { Code = code, Msg = msg };
}
internal static void ValidateFailureCode(int code)
{
if (code == ResultCode.Success)
throw new ArgumentOutOfRangeException(nameof(code), code, "失败响应不能使用成功状态码。");
}
} }
} }
-138
View File
@@ -1,138 +0,0 @@
//using MAX.Core.Infrastructure;
//using MAX.Core.Logger;
//using NLog;
//using System;
//using LLogLevel = MAX.Core.Logger.LogLevel;
//using NLogLevel = NLog.LogLevel;
//namespace MAX.Framework.Logger;
//public class NLogger : SingleInstance<NLogger>, ILoggerFacade
//{
// private readonly ILogger _log;
// private NLogger()
// {
// _log = LogManager.GetLogger("GlobalLogger");
// }
// public bool IsDebugEnabled { get; private set; } = true;
// public void Debug(Exception ex, string message)
// {
// Execute(NLogLevel.Debug, ex, message);
// }
// public void Debug(string message)
// {
// Execute(NLogLevel.Debug, message);
// }
// public void Error(Exception ex)
// {
// Execute(NLogLevel.Error, ex);
// }
// public void Error(Exception ex, string message)
// {
// Execute(NLogLevel.Error, ex, message);
// }
// public void Error(string message)
// {
// Execute(NLogLevel.Error, message);
// }
// public void Fatal(Exception ex, string message)
// {
// Execute(NLogLevel.Fatal, ex, message);
// }
// public void Fatal(string message)
// {
// Execute(NLogLevel.Fatal, message);
// }
// public void Info(Exception ex, string message)
// {
// Execute(NLogLevel.Info, ex, message);
// }
// public void Info(string message)
// {
// Execute(NLogLevel.Info, message);
// }
// public void Warn(Exception ex, string message)
// {
// Execute(NLogLevel.Warn, ex, message);
// }
// public void Warn(string message)
// {
// Execute(NLogLevel.Warn, message);
// }
// public void Log(string message, LLogLevel level)
// {
// NLogLevel lv = NLogLevel.Info;
// switch (level)
// {
// case LLogLevel.Trace:
// lv = NLogLevel.Trace;
// break;
// case LLogLevel.Debug:
// lv = NLogLevel.Debug;
// break;
// case LLogLevel.Info:
// lv = NLogLevel.Info;
// break;
// case LLogLevel.Warn:
// lv = NLogLevel.Warn;
// break;
// case LLogLevel.Error:
// lv = NLogLevel.Error;
// break;
// case LLogLevel.Fatal:
// lv = NLogLevel.Fatal;
// break;
// case LLogLevel.None:
// lv = NLogLevel.Off;
// break;
// }
// Execute(lv, message);
// }
// /// <summary>
// /// 是否启用
// /// </summary>
// private bool Enabled(NLogLevel level)
// {
// if (level > NLogLevel.Debug)
// {
// return true;
// }
// return IsDebugEnabled;
// }
// /// <summary>
// /// 执行
// /// </summary>
// private void Execute(NLogLevel level, Exception ex, string message = "")
// {
// if (Enabled(level))
// {
// _log.Log(level, ex, message, null);
// }
// }
// /// <summary>
// /// 执行
// /// </summary>
// private void Execute(NLogLevel level, string message)
// {
// if (Enabled(level))
// {
// _log.Log(level, message);
// }
// }
//}
+12 -1
View File
@@ -15,8 +15,13 @@
<PackageReference Include="FreeSql.Provider.MySql" Version="3.5.311" /> <PackageReference Include="FreeSql.Provider.MySql" Version="3.5.311" />
<PackageReference Include="FreeSql.Repository" Version="3.5.311" /> <PackageReference Include="FreeSql.Repository" Version="3.5.311" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.10" /> <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.10" />
<PackageReference Include="NLog.Web.AspNetCore" Version="6.2.0" /> <PackageReference Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.1" />
<PackageReference Include="Riok.Mapperly" Version="4.3.1" /> <PackageReference Include="Riok.Mapperly" Version="4.3.1" />
<PackageReference Include="Serilog.AspNetCore" Version="10.0.0" />
<PackageReference Include="Serilog.Settings.Configuration" Version="10.0.1" />
<PackageReference Include="Serilog.Filters.Expressions" Version="2.1.0" />
<PackageReference Include="Serilog.Sinks.Console" Version="6.1.1" />
<PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
@@ -27,4 +32,10 @@
<Folder Include="Models\" /> <Folder Include="Models\" />
</ItemGroup> </ItemGroup>
<ItemGroup>
<None Update="appsettings.Serilog.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
</Project> </Project>
+141
View File
@@ -0,0 +1,141 @@
{
"Serilog": {
"Using": [
"Serilog.Sinks.Console",
"Serilog.Sinks.File",
"Serilog.Filters.Expressions"
],
"MinimumLevel": {
"Default": "Debug",
"Override": {
"Microsoft": "Information",
"Microsoft.AspNetCore": "Warning",
"System": "Warning",
"Hangfire": "Information"
}
},
"Enrich": [
"FromLogContext"
],
"Properties": {
"Application": "MyAspNetCore"
},
"WriteTo": [
{
"Name": "Logger",
"Args": {
"configureLogger": {
"Filter": [
{ "Name": "ByIncludingOnly", "Args": { "expression": "@Level = 'Debug'" } }
],
"WriteTo": [
{
"Name": "File",
"Args": {
"path": "Logs/Debug/.log",
"rollingInterval": "Day",
"outputTemplate": "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}",
"retainedFileCountLimit": 365,
"fileSizeLimitBytes": 104857600,
"rollOnFileSizeLimit": true
}
}
]
}
}
},
{
"Name": "Logger",
"Args": {
"configureLogger": {
"Filter": [
{ "Name": "ByIncludingOnly", "Args": { "expression": "@Level = 'Information'" } }
],
"WriteTo": [
{
"Name": "File",
"Args": {
"path": "Logs/Info/.log",
"rollingInterval": "Day",
"outputTemplate": "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}",
"retainedFileCountLimit": 365,
"fileSizeLimitBytes": 104857600,
"rollOnFileSizeLimit": true
}
}
]
}
}
},
{
"Name": "Logger",
"Args": {
"configureLogger": {
"Filter": [
{ "Name": "ByIncludingOnly", "Args": { "expression": "@Level = 'Warning'" } }
],
"WriteTo": [
{
"Name": "File",
"Args": {
"path": "Logs/Warning/.log",
"rollingInterval": "Day",
"outputTemplate": "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}",
"retainedFileCountLimit": 365,
"fileSizeLimitBytes": 104857600,
"rollOnFileSizeLimit": true
}
}
]
}
}
},
{
"Name": "Logger",
"Args": {
"configureLogger": {
"Filter": [
{ "Name": "ByIncludingOnly", "Args": { "expression": "@Level = 'Error'" } }
],
"WriteTo": [
{
"Name": "File",
"Args": {
"path": "Logs/Error/.log",
"rollingInterval": "Day",
"outputTemplate": "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}",
"retainedFileCountLimit": 365,
"fileSizeLimitBytes": 104857600,
"rollOnFileSizeLimit": true
}
}
]
}
}
},
{
"Name": "Logger",
"Args": {
"configureLogger": {
"Filter": [
{ "Name": "ByIncludingOnly", "Args": { "expression": "@Level = 'Fatal'" } }
],
"WriteTo": [
{
"Name": "File",
"Args": {
"path": "Logs/Fatal/.log",
"rollingInterval": "Day",
"outputTemplate": "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}",
"retainedFileCountLimit": 365,
"fileSizeLimitBytes": 104857600,
"rollOnFileSizeLimit": true
}
}
]
}
}
}
]
}
}
+1
View File
@@ -9,6 +9,7 @@
<CheckEolTargetFramework>false</CheckEolTargetFramework> <CheckEolTargetFramework>false</CheckEolTargetFramework>
<SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage> <SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
<Nullable>annotations</Nullable> <Nullable>annotations</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<NoWarn>CS1591</NoWarn> <NoWarn>CS1591</NoWarn>
</PropertyGroup> </PropertyGroup>
@@ -12,19 +12,11 @@ using Store.Modules.CloudProduct.Services;
namespace Store.Modules.CloudProduct namespace Store.Modules.CloudProduct
{ {
/// <summary>
/// CloudProduct 模块的模块化入口(<see cref="IModule"/>):Hangfire 后台任务(商品分词同步)+ Hangfire 看板。
/// 与 <see cref="Startup"/>(只做 IStartup 的 Initialize/Register)分开,是因为模块注册需要配置和 app:
/// <list type="bullet">
/// <item><c>builder.AddStoreHub()</c> 执行 <see cref="AddModule"/>(注册 Hangfire 服务,此时只能拿到容器和配置);</item>
/// <item><c>app.UseStoreHubModules()</c> 执行 <see cref="UseModule"/>(挂看板中间件 + 注册定时任务,此时才有 app)。</item>
/// </list>
/// </summary>
public class CloudProductModule : IModule public class CloudProductModule : IModule
{ {
/// <summary> /// <summary>
/// 本模块自己的配置文件(源码里是 Models/CloudProduct/appsettings.json, /// 本模块自己的配置文件
/// 构建时复制到宿主输出目录并改名成这个名字,避免与宿主的 appsettings.json 冲突)
/// </summary> /// </summary>
public const string ConfigurationFileName = "appsettings.CloudProduct.json"; public const string ConfigurationFileName = "appsettings.CloudProduct.json";
@@ -51,11 +43,12 @@ namespace Store.Modules.CloudProduct
//// 本模块的配置节(Search / RawData / Indexing / Delete)都在模块自己的配置文件里, //// 本模块的配置节(Search / RawData / Indexing / Delete)都在模块自己的配置文件里,
//// 关键项缺失直接报错,避免 OpenSearch 地址为空、原始数据写到意外目录之类的隐性故障 //// 关键项缺失直接报错,避免 OpenSearch 地址为空、原始数据写到意外目录之类的隐性故障
RequireConfiguration(configuration, "Search:Url"); RequireConfiguration(configuration, "Search:Url");
//RequireConfiguration(configuration, "Search:IndexName"); RequireConfiguration(configuration, "Search:IndexName");
//RequireConfiguration(configuration, "RawData:Path"); RequireConfiguration(configuration, "Search:FavoritesIndexName");
RequireConfiguration(configuration, "RawData:Path");
// ===== Hangfire 后台定时任务(商品分词同步) ===== // ===== Hangfire 后台定时任务(商品分词同步) =====
var hangfireConnection = configuration.GetConnectionString("DefaultConnection") var hangfireConnection = configuration.GetValue<string>("CloudProductConnection")
?? throw new InvalidOperationException("缺少配置 ConnectionStrings:DefaultConnection,CloudProduct 模块的 Hangfire 无法启动。"); ?? throw new InvalidOperationException("缺少配置 ConnectionStrings:DefaultConnection,CloudProduct 模块的 Hangfire 无法启动。");
// AllowUserVariables=true:Hangfire.MySqlStorage 的建表/查询语句依赖用户变量 // AllowUserVariables=true:Hangfire.MySqlStorage 的建表/查询语句依赖用户变量
@@ -71,6 +64,9 @@ namespace Store.Modules.CloudProduct
.UseStorage(new MySqlStorage(connectionStringBuilder.ConnectionString, new MySqlStorageOptions() { TablesPrefix = "Hangfire_" }))); .UseStorage(new MySqlStorage(connectionStringBuilder.ConnectionString, new MySqlStorageOptions() { TablesPrefix = "Hangfire_" })));
services.AddHangfireServer(); services.AddHangfireServer();
services.AddTransient<GoodsIndexJob>(); services.AddTransient<GoodsIndexJob>();
services.AddTransient<GoodsViolationIndexJob>();
services.AddAuthorization(options => options.AddPolicy("CloudGoodsViolationWrite",
policy => policy.RequireAuthenticatedUser().RequireClaim("permission", "cloudgoods:violation:write")));
} }
@@ -103,6 +99,8 @@ namespace Store.Modules.CloudProduct
"goods-index-pending", "goods-index-pending",
job => job.ProcessPendingAsync(), job => job.ProcessPendingAsync(),
cron); cron);
app.ApplicationServices.GetRequiredService<IRecurringJobManager>().AddOrUpdate<GoodsViolationIndexJob>(
"goods-violation-delete-pending", job => job.ProcessPendingAsync(), "* * * * *");
} }
catch (Exception ex) catch (Exception ex)
{ {
@@ -2,6 +2,7 @@ using Asp.Versioning;
using MAX.Framework.Commons; using MAX.Framework.Commons;
using MAX.Framework.Dtos; using MAX.Framework.Dtos;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Store.Framework.Base; using Store.Framework.Base;
using Store.Modules.CloudProduct.Dtos; using Store.Modules.CloudProduct.Dtos;
@@ -12,39 +13,72 @@ using System.Text.Json.Nodes;
namespace Store.Modules.CloudProduct.Controllers namespace Store.Modules.CloudProduct.Controllers
{ {
/// <summary>云商品管理:商品查询、导入、违规上报及搜索索引维护。</summary>
[Tags("云商品")]
[ApiVersionNeutral] [ApiVersionNeutral]
[Route("/CloudGoods/[action]")] [Route("api/CloudGoods/[action]")]
public class GoodsController : AppControllerBase public class GoodsController : AppControllerBase
{ {
private readonly IGoodsService _goodsService; private readonly IGoodsService _goodsService;
private readonly IOpenSearchService _searchService; private readonly IOpenSearchService _searchService;
private readonly IRawDataStorage _rawDataStorage; private readonly IRawDataStorage _rawDataStorage;
private readonly GoodsIndexJob _goodsIndexJob; private readonly GoodsIndexJob _goodsIndexJob;
private readonly GoodsViolationService _violations;
public GoodsController(IGoodsService goodsService, IOpenSearchService searchService, IRawDataStorage rawDataStorage, GoodsIndexJob goodsIndexJob) public GoodsController(IGoodsService goodsService, IOpenSearchService searchService, IRawDataStorage rawDataStorage, GoodsIndexJob goodsIndexJob, GoodsViolationService violations)
{ {
_violations = violations;
_goodsService = goodsService; _goodsService = goodsService;
_searchService = searchService; _searchService = searchService;
_rawDataStorage = rawDataStorage; _rawDataStorage = rawDataStorage;
_goodsIndexJob = goodsIndexJob; _goodsIndexJob = goodsIndexJob;
} }
/// <summary>获取全部违规原因字典,包含未启用违规判定的原因,按ID升序返回。</summary>
[HttpGet] [HttpGet]
[EndpointSummary("获取违规原因字典")]
public Task<List<ViolationReasonDto>> GetViolationReasons()
=> _violations.GetReasonsAsync();
/// <summary>批量上报违规商品;重复上报合并原因。</summary>
[HttpPost]
[EndpointSummary("批量上报违规商品")]
public Task<List<ReportGoodsViolationsResult>> ReportViolations([FromBody] ReportGoodsViolationItem[] items)
=> _violations.ReportAsync(items);
/// <summary>批量解除商品违规,恢复正常商品索引;失败后由后台索引任务重试。</summary>
[HttpPost]
[EndpointSummary("解除商品违规并恢复索引")]
public Task<RemoveGoodsViolationsResult> RemoveViolations([FromBody] long[] ids)
=> _violations.RemoveAsync(ids);
/// <summary>按商品编号批量查询是否违规。</summary>
[HttpPost]
[EndpointSummary("批量查询商品违规状态")]
public Task<List<GoodsViolationStatus>> GetViolationStatus([FromBody] long[] ids)
=> _violations.GetStatusAsync(ids);
/// <summary>获取服务器当前日期(长日期格式)。</summary>
[HttpGet]
[EndpointSummary("获取服务器当前日期")]
public async Task<string> Time() public async Task<string> Time()
{ {
return DateTime.Now.ToLongDateString(); return DateTime.Now.ToLongDateString();
} }
/// <summary>手动执行待处理商品的索引任务。</summary>
[HttpGet] [HttpGet]
[EndpointSummary("处理待建立索引的商品")]
public async Task Job() public async Task Job()
{ {
await _goodsIndexJob.ProcessPendingAsync(); await _goodsIndexJob.ProcessPendingAsync();
} }
/// <summary> /// <summary>
/// 搜索 /// 分页搜索商品,可按标题、价格、类目、销量和平台筛选。
/// </summary> /// </summary>
/// <param name="request"></param> /// <param name="request">商品筛选条件及分页参数。</param>
/// <returns></returns> /// <returns>符合条件的商品列表及总数。</returns>
[HttpPost] [HttpPost]
[EndpointSummary("分页搜索商品")]
public async Task<PageData<GoodsEntity>> SearchGoods(GoodsSearchRequest request) public async Task<PageData<GoodsEntity>> SearchGoods(GoodsSearchRequest request)
{ {
// 1. 参数基础校验 // 1. 参数基础校验
@@ -145,6 +179,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// </summary> /// </summary>
[HttpGet] [HttpGet]
[ActionName("SearchGoodsToIds")] [ActionName("SearchGoodsToIds")]
[EndpointSummary("按关键词搜索商品摘要")]
public async Task<PageData<GoodsSearchDocument>> SearchGoodsSummary(string keyword, int pageindex = 1, int pagesize = 20) public async Task<PageData<GoodsSearchDocument>> SearchGoodsSummary(string keyword, int pageindex = 1, int pagesize = 20)
{ {
if (string.IsNullOrWhiteSpace(keyword)) if (string.IsNullOrWhiteSpace(keyword))
@@ -172,6 +207,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 导入测试数据:读取 ImportConverters/data.txt 并走完整解析 + 入库 + 分词流程。 /// 导入测试数据:读取 ImportConverters/data.txt 并走完整解析 + 入库 + 分词流程。
/// </summary> /// </summary>
[HttpGet] [HttpGet]
[EndpointSummary("导入测试商品数据")]
public async Task<GoodsImportResult> ImportTestData() public async Task<GoodsImportResult> ImportTestData()
{ {
var filePath = GetDataFilePath(); var filePath = GetDataFilePath();
@@ -198,6 +234,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 导入接口:接收客户端批量上传的 JSON 文件,解析后入库并写入分词索引。 /// 导入接口:接收客户端批量上传的 JSON 文件,解析后入库并写入分词索引。
/// </summary> /// </summary>
[HttpPost] [HttpPost]
[EndpointSummary("批量导入商品 JSON 文件")]
public async Task<GoodsImportResult> ImportFiles([FromForm] List<IFormFile> files) public async Task<GoodsImportResult> ImportFiles([FromForm] List<IFormFile> files)
{ {
if (files == null || files.Count == 0) if (files == null || files.Count == 0)
@@ -247,6 +284,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 查询 OpenSearch 状态。 /// 查询 OpenSearch 状态。
/// </summary> /// </summary>
[HttpGet] [HttpGet]
[EndpointSummary("查询 OpenSearch 服务状态")]
public async Task<OpenSearchStatusDto> GetOpenSearchStatus() public async Task<OpenSearchStatusDto> GetOpenSearchStatus()
{ {
return await _searchService.GetStatusAsync(); return await _searchService.GetStatusAsync();
@@ -256,6 +294,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 检查搜索索引是否存在。 /// 检查搜索索引是否存在。
/// </summary> /// </summary>
[HttpGet] [HttpGet]
[EndpointSummary("检查商品搜索索引是否存在")]
public async Task<bool> IndexExists() public async Task<bool> IndexExists()
{ {
return await _searchService.IndexExistsAsync(); return await _searchService.IndexExistsAsync();
@@ -265,6 +304,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 检查索引映射(分析器)是否符合当前服务要求。 /// 检查索引映射(分析器)是否符合当前服务要求。
/// </summary> /// </summary>
[HttpGet] [HttpGet]
[EndpointSummary("检查商品索引映射是否正常")]
public async Task<bool> IndexMappingHealthy() public async Task<bool> IndexMappingHealthy()
{ {
return await _searchService.IsIndexMappingHealthyAsync(); return await _searchService.IsIndexMappingHealthyAsync();
@@ -274,6 +314,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 创建搜索索引(含 IK 分词映射,已存在且映射正常时跳过)。 /// 创建搜索索引(含 IK 分词映射,已存在且映射正常时跳过)。
/// </summary> /// </summary>
[HttpPost] [HttpPost]
[EndpointSummary("创建商品搜索索引")]
public async Task<bool> CreateIndex() public async Task<bool> CreateIndex()
{ {
return await _searchService.CreateIndexAsync(); return await _searchService.CreateIndexAsync();
@@ -283,6 +324,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 删除搜索索引。 /// 删除搜索索引。
/// </summary> /// </summary>
[HttpPost] [HttpPost]
[EndpointSummary("删除商品搜索索引")]
public async Task DeleteIndex() public async Task DeleteIndex()
{ {
await _searchService.DeleteIndexAsync(); await _searchService.DeleteIndexAsync();
@@ -292,6 +334,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 手动刷新搜索索引,使最新写入立即可搜索。 /// 手动刷新搜索索引,使最新写入立即可搜索。
/// </summary> /// </summary>
[HttpPost] [HttpPost]
[EndpointSummary("刷新商品搜索索引")]
public async Task RefreshIndex() public async Task RefreshIndex()
{ {
await _searchService.RefreshIndexAsync(); await _searchService.RefreshIndexAsync();
@@ -301,6 +344,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 手动新增或覆盖一条搜索文档。 /// 手动新增或覆盖一条搜索文档。
/// </summary> /// </summary>
[HttpPost] [HttpPost]
[EndpointSummary("新增或覆盖商品搜索文档")]
public async Task AddSearchDocument([FromBody] GoodsSearchDocument document) public async Task AddSearchDocument([FromBody] GoodsSearchDocument document)
{ {
if (document == null || document.Id <= 0) if (document == null || document.Id <= 0)
@@ -314,28 +358,45 @@ namespace Store.Modules.CloudProduct.Controllers
/// <summary> /// <summary>
/// 读取指定商品详情:解压缩原始数据并返回 JSON。 /// 读取指定商品详情:解压缩原始数据并返回 JSON。
/// </summary> /// </summary>
[HttpGet] [HttpPost]
[EndpointSummary("查询商品详情")]
public async Task<JsonNode> GetGoodsDetail([FromQuery] long goodsId) public async Task<JsonNode> GetGoodsDetail([FromQuery] long goodsId)
{
try
{ {
var raw = await GetRawDataOrThrowAsync(goodsId); var raw = await GetRawDataOrThrowAsync(goodsId);
var node = JsonNode.Parse(raw); var node = JsonNode.Parse(raw);
return node ?? throw new AppException("商品详情解析失败", ResultCode.BusinessError); return node ?? throw new AppException("商品详情解析失败", ResultCode.BusinessError);
} }
catch(Exception ex)
{
throw new AppException(ex.Message);
}
}
/// <summary> /// <summary>
/// 读取指定商品的原始数据(解压缩后原样返回)。 /// 读取指定商品的原始数据(解压缩后原样返回)。
/// </summary> /// </summary>
[HttpGet] [HttpPost]
[EndpointSummary("读取商品原始数据")]
public async Task<string> GetGoodsRawData([FromQuery] long goodsId) public async Task<string> GetGoodsRawData([FromQuery] long goodsId)
{
try
{ {
return await GetRawDataOrThrowAsync(goodsId); return await GetRawDataOrThrowAsync(goodsId);
} }
catch (Exception ex)
{
throw new AppException(ex.Message);
}
}
/// <summary> /// <summary>
/// 重新从数据库读取指定商品,覆盖 OpenSearch 已有分词并重新分词。 /// 重新从数据库读取指定商品,覆盖 OpenSearch 已有分词并重新分词。
/// ids 为空时重建全部商品。 /// ids 为空时重建全部商品。
/// </summary> /// </summary>
[HttpPost] [HttpPost]
[EndpointSummary("重建商品搜索文档")]
public async Task<long> RebuildIndex([FromBody] long[]? ids) public async Task<long> RebuildIndex([FromBody] long[]? ids)
{ {
return await _goodsService.RebuildSearchIndexAsync(ids); return await _goodsService.RebuildSearchIndexAsync(ids);
@@ -346,6 +407,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// 软删除将 Status 置 1,硬删除物理删除记录;两种方式都会删除 OpenSearch 中对应文档。 /// 软删除将 Status 置 1,硬删除物理删除记录;两种方式都会删除 OpenSearch 中对应文档。
/// </summary> /// </summary>
[HttpPost] [HttpPost]
[EndpointSummary("批量删除商品")]
public async Task<long> DeleteGoods([FromBody] long[]? ids) public async Task<long> DeleteGoods([FromBody] long[]? ids)
{ {
if (ids == null || ids.Length == 0) if (ids == null || ids.Length == 0)
@@ -361,6 +423,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// </summary> /// </summary>
[HttpGet] [HttpGet]
[ActionName("ClearSearch")] [ActionName("ClearSearch")]
[EndpointSummary("清空并重建商品搜索索引")]
public async Task<bool> ClearSearchIndex() public async Task<bool> ClearSearchIndex()
{ {
return await _searchService.ClearIndexAsync(); return await _searchService.ClearIndexAsync();
@@ -371,6 +434,7 @@ namespace Store.Modules.CloudProduct.Controllers
/// </summary> /// </summary>
[HttpGet] [HttpGet]
[ActionName("GetSearchCount")] [ActionName("GetSearchCount")]
[EndpointSummary("统计商品搜索文档数量")]
public async Task<long> GetSearchDocumentCount() public async Task<long> GetSearchDocumentCount()
{ {
return await _searchService.CountDocumentsAsync(); return await _searchService.CountDocumentsAsync();
@@ -383,7 +447,10 @@ namespace Store.Modules.CloudProduct.Controllers
var raw = await _rawDataStorage.ReadAsync(goodsId); var raw = await _rawDataStorage.ReadAsync(goodsId);
if (raw == null) if (raw == null)
{
System.IO.File.WriteAllText("./NoGoods.txt", goodsId.ToString());
throw new AppException($"商品原始数据不存在: {goodsId}", ResultCode.NotFound); throw new AppException($"商品原始数据不存在: {goodsId}", ResultCode.NotFound);
}
return raw; return raw;
} }
@@ -0,0 +1,269 @@
using Asp.Versioning;
using MAX.Framework.Commons;
using MAX.Framework.Dtos;
using MAX.Framework.Security;
using Microsoft.AspNetCore.Mvc;
using Store.Framework.Base;
using Store.Modules.CloudProduct.Dtos;
using Store.Modules.CloudProduct.Services;
namespace Store.Modules.CloudProduct.Controllers
{
/// <summary>
/// 用户收藏商品:收藏/取消收藏(数据库 + 收藏索引同步)、收藏分组、收藏状态查询、收藏检索与索引重建。
/// 请求中的 userName 允许为空,为空时取当前登录用户。
/// </summary>
[ApiVersionNeutral]
[Route("api/CloudGoods/[action]")]
public class UserFavoritesController : AppControllerBase
{
private readonly IUserFavoritesService _favoritesService;
private readonly ICurrentUser _currentUser;
public UserFavoritesController(IUserFavoritesService favoritesService, ICurrentUser currentUser)
{
_favoritesService = favoritesService;
_currentUser = currentUser;
}
/// <summary>
/// 批量收藏商品:写入 user_goods_favorites 并同步写入收藏索引,返回本次成功收藏的商品数量。
/// 商品已收藏时视为修改收藏分组;商品不存在/已删除的编号会被跳过。
/// </summary>
[HttpPost]
public async Task<int> AddFavorite(AddUserFavoriteRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
request.UserName = ResolveUserName(request.UserName);
if (string.IsNullOrWhiteSpace(request.UserName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
if (request.GoodsIds == null || request.GoodsIds.Count == 0)
{
throw new AppException("请提供要收藏的商品编号", ResultCode.ValidationError);
}
if (request.GroupId < 0)
{
throw new AppException("收藏分组无效", ResultCode.ValidationError);
}
return await _favoritesService.AddFavoritesAsync(request);
}
/// <summary>
/// 批量取消收藏:删除 user_goods_favorites 记录并同步删除收藏索引文档,返回实际取消的条数。
/// </summary>
[HttpPost]
public async Task<int> RemoveFavorites(RemoveUserFavoritesRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
request.UserName = ResolveUserName(request.UserName);
if (string.IsNullOrWhiteSpace(request.UserName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
if (request.GoodsIds == null || request.GoodsIds.Count == 0)
{
throw new AppException("请提供要取消收藏的商品编号", ResultCode.ValidationError);
}
return await _favoritesService.RemoveFavoritesAsync(request);
}
/// <summary>
/// 创建收藏分组:创建成功返回 true,同名分组已存在返回 false。
/// </summary>
[HttpPost]
public async Task<bool> CreateGroup(CreateUserFavoriteGroupRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
request.UserName = ResolveUserName(request.UserName);
if (string.IsNullOrWhiteSpace(request.UserName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
if (string.IsNullOrWhiteSpace(request.GroupName))
{
throw new AppException("分组名不能为空", ResultCode.ValidationError);
}
return await _favoritesService.CreateGroupAsync(request);
}
/// <summary>
/// 查询用户的收藏分组(含默认分组)及分组下收藏数量。
/// </summary>
[HttpGet]
public async Task<List<UserFavoriteGroupDto>> GetGroups(string? userName = null)
{
var resolved = ResolveUserName(userName);
if (string.IsNullOrWhiteSpace(resolved))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
return await _favoritesService.GetGroupsAsync(resolved);
}
/// <summary>
/// 按 GoodsIds 顺序返回每个商品是否已被收藏(如 [true,false,...]),前台可按顺序直接渲染。
/// </summary>
[HttpPost]
public async Task<List<bool>> GetFavoriteStatus(UserFavoriteStatusRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
request.UserName = ResolveUserName(request.UserName);
if (string.IsNullOrWhiteSpace(request.UserName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
return await _favoritesService.GetFavoriteStatusAsync(request);
}
/// <summary>
/// 检索用户收藏的商品(标题、销量、价格、类目、分组)。
/// </summary>
[HttpPost]
public async Task<PageData<UserFavoriteItem>> SearchFavorites(UserFavoritesSearchRequest request)
{
// 1. 参数基础校验
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
request.UserName = ResolveUserName(request.UserName);
if (string.IsNullOrWhiteSpace(request.UserName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
// 2. 分页参数校验
if (request.PageIndex < 1)
{
throw new AppException("页码必须大于0", ResultCode.ValidationError);
}
if (request.PageSize < 1 || request.PageSize > 2000)
{
throw new AppException("每页数量必须在1-2000之间", ResultCode.ValidationError);
}
// 3. 价格区间校验
if (request.MinPrice.HasValue && request.MinPrice < 0)
{
throw new AppException("最低价格不能小于0", ResultCode.ValidationError);
}
if (request.MaxPrice.HasValue && request.MaxPrice < 0)
{
throw new AppException("最高价格不能小于0", ResultCode.ValidationError);
}
if (request.MinPrice.HasValue && request.MaxPrice.HasValue && request.MinPrice > request.MaxPrice)
{
throw new AppException("最低价格不能大于最高价格", ResultCode.ValidationError);
}
// 4. 销量区间校验
if (request.MinSoldQuantity.HasValue && request.MinSoldQuantity < 0)
{
throw new AppException("最低销量不能小于0", ResultCode.ValidationError);
}
if (request.MaxSoldQuantity.HasValue && request.MaxSoldQuantity < 0)
{
throw new AppException("最高销量不能小于0", ResultCode.ValidationError);
}
if (request.MinSoldQuantity.HasValue && request.MaxSoldQuantity.HasValue &&
request.MinSoldQuantity > request.MaxSoldQuantity)
{
throw new AppException("最低销量不能大于最高销量", ResultCode.ValidationError);
}
// 5. 类目层级校验
if (request.CatId2.HasValue && !request.CatId1.HasValue)
{
throw new AppException("选择二级类目时必须先选择一级类目", ResultCode.ValidationError);
}
if (request.CatId3.HasValue && !request.CatId2.HasValue)
{
throw new AppException("选择三级类目时必须先选择二级类目", ResultCode.ValidationError);
}
if (request.CatId4.HasValue && !request.CatId3.HasValue)
{
throw new AppException("选择四级类目时必须先选择三级类目", ResultCode.ValidationError);
}
// 6. 分组校验
if (request.GroupId.HasValue && request.GroupId < 0)
{
throw new AppException("收藏分组无效", ResultCode.ValidationError);
}
// 7. 平台校验
if (request.Platform.HasValue && request.Platform < 0)
{
throw new AppException("平台类型无效", ResultCode.ValidationError);
}
var result = await _favoritesService.SearchFavoritesAsync(request);
return new PageData<UserFavoriteItem>
{
List = result.List,
Total = result.Total,
PageSize = request.PageSize,
PageIndex = request.PageIndex,
};
}
/// <summary>
/// 移除所有用户收藏索引并重新创建,随后按 user_goods_favorites 关联 goods 全量回填。
/// </summary>
[HttpPost]
public async Task<long> RebuildSearchIndex()
{
return await _favoritesService.RebuildSearchIndexAsync();
}
/// <summary>
/// 取用户名:显式传入优先,否则取当前登录用户。
/// </summary>
private string ResolveUserName(string? userName)
{
return string.IsNullOrWhiteSpace(userName)
? (_currentUser.UserName ?? string.Empty)
: userName.Trim();
}
}
}
@@ -0,0 +1,23 @@
namespace Store.Modules.CloudProduct.Dtos
{
/// <summary>
/// 收藏商品请求(支持多选批量收藏)
/// </summary>
public class AddUserFavoriteRequest
{
/// <summary>
/// 用户名(为空时取当前登录用户)
/// </summary>
public string UserName { get; set; } = string.Empty;
/// <summary>
/// 商品编号集合(可多选)
/// </summary>
public List<long> GoodsIds { get; set; } = new();
/// <summary>
/// 收藏分组ID(默认0,表示默认分组;大于0时必须存在且属于该用户)
/// </summary>
public int GroupId { get; set; }
}
}
@@ -0,0 +1,18 @@
namespace Store.Modules.CloudProduct.Dtos
{
/// <summary>
/// 创建收藏分组请求
/// </summary>
public class CreateUserFavoriteGroupRequest
{
/// <summary>
/// 用户名(为空时取当前登录用户)
/// </summary>
public string UserName { get; set; } = string.Empty;
/// <summary>
/// 分组名
/// </summary>
public string GroupName { get; set; } = string.Empty;
}
}
@@ -0,0 +1,36 @@
namespace Store.Modules.CloudProduct.Dtos;
public class ViolationReasonDto
{
public string Name { get; set; } = string.Empty;
public bool IsViolation { get; set; }
}
public class ReportGoodsViolationItem
{
public long GoodsId { get; set; }
/// <summary>原因名称,例如“出售假冒商品”;新名称默认仅记录字典,不判定违规。</summary>
public string Reasons { get; set; } = string.Empty;
}
public class ReportGoodsViolationsResult
{
public long GoodsId { get; set; }
/// <summary>存在违规记录且已完成索引下架时为 true,否则为 false。</summary>
public bool IsOffShelf { get; set; }
}
public class GoodsViolationStatus
{
public long GoodsId { get; set; }
public bool IsViolation { get; set; }
}
public class RemoveGoodsViolationsResult
{
public int RemovedCount { get; set; }
public long[] RestoredGoodsIds { get; set; } = [];
public long[] PendingRestoreGoodsIds { get; set; } = [];
/// <summary>商品不存在、已删除或恢复期间再次被上报违规的编号。</summary>
public long[] SkippedGoodsIds { get; set; } = [];
}
@@ -0,0 +1,18 @@
namespace Store.Modules.CloudProduct.Dtos
{
/// <summary>
/// 取消收藏(批量)请求
/// </summary>
public class RemoveUserFavoritesRequest
{
/// <summary>
/// 用户名(为空时取当前登录用户)
/// </summary>
public string UserName { get; set; } = string.Empty;
/// <summary>
/// 要取消收藏的商品编号集合
/// </summary>
public List<long> GoodsIds { get; set; } = new();
}
}
@@ -0,0 +1,20 @@
namespace Store.Modules.CloudProduct.Dtos
{
/// <summary>
/// 用户收藏分组
/// </summary>
public class UserFavoriteGroupDto
{
/// <summary>分组ID</summary>
public long Id { get; set; }
/// <summary>用户名</summary>
public string UserName { get; set; } = string.Empty;
/// <summary>分组名</summary>
public string GroupName { get; set; } = string.Empty;
/// <summary>该分组下的收藏数量</summary>
public long FavoriteCount { get; set; }
}
}
@@ -0,0 +1,53 @@
namespace Store.Modules.CloudProduct.Dtos
{
/// <summary>
/// 用户收藏商品(索引文档回显模型)
/// </summary>
public class UserFavoriteItem
{
/// <summary>收藏记录自增主键</summary>
public long Id { get; set; }
/// <summary>用户名</summary>
public string UserName { get; set; } = string.Empty;
/// <summary>收藏分组ID(0 表示默认分组)</summary>
public int GroupId { get; set; }
/// <summary>收藏分组名</summary>
public string GroupName { get; set; } = string.Empty;
/// <summary>商品编号</summary>
public long GoodsId { get; set; }
/// <summary>平台类型</summary>
public byte Platform { get; set; }
/// <summary>商品标题</summary>
public string Title { get; set; } = string.Empty;
/// <summary>缩略图</summary>
public string? ThumbUrl { get; set; }
/// <summary>一级类目ID</summary>
public int? CatId1 { get; set; }
/// <summary>二级类目ID</summary>
public int? CatId2 { get; set; }
/// <summary>三级类目ID</summary>
public int? CatId3 { get; set; }
/// <summary>四级类目ID</summary>
public int? CatId4 { get; set; }
/// <summary>最低价快照(分)</summary>
public long? MinPrice { get; set; }
/// <summary>销量</summary>
public int SoldQuantity { get; set; }
/// <summary>收藏时间</summary>
public DateTime CreatedAt { get; set; }
}
}
@@ -0,0 +1,18 @@
namespace Store.Modules.CloudProduct.Dtos
{
/// <summary>
/// 查询商品是否已被收藏请求:按 GoodsIds 顺序返回是否已收藏
/// </summary>
public class UserFavoriteStatusRequest
{
/// <summary>
/// 用户名(为空时取当前登录用户)
/// </summary>
public string UserName { get; set; } = string.Empty;
/// <summary>
/// 商品编号集合
/// </summary>
public List<long> GoodsIds { get; set; } = new();
}
}
@@ -0,0 +1,87 @@
using OpenSearch.Client;
namespace Store.Modules.CloudProduct.Dtos
{
/// <summary>
/// 用户收藏商品搜索文档:OpenSearch 索引中的收藏模型。
/// 一条收藏记录 = 用户 + 商品快照(标题/价格/销量/类目)+ 收藏分组,
/// 文档 Id 固定为 "{user_name}:{goods_id}"(表 uk_user_goods 保证唯一),便于收藏/取消收藏时幂等覆盖与删除。
/// </summary>
public class UserFavoritesSearchDocument
{
/// <summary>
/// 文档主键(同时作为 OpenSearch 的 _id):{user_name}:{goods_id}
/// </summary>
[Keyword(Name = "id")]
public string Id { get; set; } = string.Empty;
/// <summary>
/// 收藏记录自增主键(user_goods_favorites.id)
/// </summary>
[Number(NumberType.Long, Name = "fav_id")]
public long FavId { get; set; }
/// <summary>用户名(收藏归属人,检索时强制过滤)</summary>
[Keyword(Name = "user_name")]
public string UserName { get; set; } = string.Empty;
/// <summary>收藏分组ID(0 表示默认分组)</summary>
[Number(NumberType.Integer, Name = "group_id")]
public int GroupId { get; set; }
/// <summary>收藏分组名(分组ID为0时为默认分组名)</summary>
[Keyword(Name = "group_name")]
public string GroupName { get; set; } = string.Empty;
/// <summary>商品编号</summary>
[Number(NumberType.Long, Name = "goods_id")]
public long GoodsId { get; set; }
/// <summary>平台类型(1 PDD、2 WX)</summary>
[Number(NumberType.Byte, Name = "platform")]
public byte Platform { get; set; }
/// <summary>商品标题,用于分词搜索</summary>
[Text(Name = "title", Analyzer = "ik_max_word", SearchAnalyzer = "ik_smart")]
public string Title { get; set; } = string.Empty;
/// <summary>缩略图</summary>
[Text(Name = "thumb_url")]
public string? ThumbUrl { get; set; }
/// <summary>一级类目ID</summary>
[Number(NumberType.Integer, Name = "cat_id_1")]
public int? CatId1 { get; set; }
/// <summary>二级类目ID</summary>
[Number(NumberType.Integer, Name = "cat_id_2")]
public int? CatId2 { get; set; }
/// <summary>三级类目ID</summary>
[Number(NumberType.Integer, Name = "cat_id_3")]
public int? CatId3 { get; set; }
/// <summary>四级类目ID</summary>
[Number(NumberType.Integer, Name = "cat_id_4")]
public int? CatId4 { get; set; }
/// <summary>最低价快照(分),用于价格区间过滤和按价格排序</summary>
[Number(NumberType.Long, Name = "min_price")]
public long? MinPrice { get; set; }
/// <summary>销量,用于按销量排序</summary>
[Number(NumberType.Integer, Name = "sold_quantity")]
public int SoldQuantity { get; set; }
/// <summary>收藏时间,默认按此字段倒序</summary>
[Date(Name = "created_at")]
public DateTime CreatedAt { get; set; }
/// <summary>
/// 生成文档主键:{user_name}:{goods_id}
/// </summary>
public static string BuildId(string userName, long goodsId) => $"{userName}:{goodsId}";
public override string ToString() => $"[Id={Id}] User={UserName} Goods={GoodsId} Group={GroupId}({GroupName}) Title={Title} Price={MinPrice} Sold={SoldQuantity}";
}
}
@@ -0,0 +1,88 @@
namespace Store.Modules.CloudProduct.Dtos
{
/// <summary>
/// 用户收藏商品搜索请求(仅检索当前用户自己的收藏)
/// </summary>
public class UserFavoritesSearchRequest
{
/// <summary>
/// 用户名(为空时取当前登录用户)
/// </summary>
public string UserName { get; set; } = string.Empty;
/// <summary>
/// 标题关键字(分词模糊搜索)
/// </summary>
public string? Title { get; set; }
/// <summary>
/// 收藏分组ID(0 表示默认分组)
/// </summary>
public int? GroupId { get; set; }
/// <summary>
/// 收藏分组名(与分组ID二选一,同时传入时以分组ID为准)
/// </summary>
public string? GroupName { get; set; }
/// <summary>
/// 最低价格(分)
/// </summary>
public long? MinPrice { get; set; }
/// <summary>
/// 最高价格(分)
/// </summary>
public long? MaxPrice { get; set; }
/// <summary>
/// 一级类目ID
/// </summary>
public int? CatId1 { get; set; }
/// <summary>
/// 二级类目ID
/// </summary>
public int? CatId2 { get; set; }
/// <summary>
/// 三级类目ID
/// </summary>
public int? CatId3 { get; set; }
/// <summary>
/// 四级类目ID
/// </summary>
public int? CatId4 { get; set; }
/// <summary>
/// 最低销量
/// </summary>
public int? MinSoldQuantity { get; set; }
/// <summary>
/// 最高销量
/// </summary>
public int? MaxSoldQuantity { get; set; }
/// <summary>
/// 平台类型
/// </summary>
public byte? Platform { get; set; }
/// <summary>
/// 页码(默认1)
/// </summary>
public int PageIndex { get; set; } = 1;
/// <summary>
/// 每页数量(默认20)
/// </summary>
public int PageSize { get; set; } = 20;
/// <summary>
/// 排序方式:CreatedTimeDesc(默认,收藏时间倒序)/ CreatedTimeAsc / PriceAsc / PriceDesc / SoldDesc
/// </summary>
public string SortBy { get; set; } = "CreatedTimeDesc";
}
}
@@ -0,0 +1,22 @@
using FreeSql.DataAnnotations;
namespace Store.Modules.CloudProduct.Entities;
[Table(Name = "goods_violation")]
public class GoodsViolationEntity
{
[Column(Name = "goods_id", IsPrimary = true)]
public long GoodsId { get; set; }
[Column(Name = "reason_id", IsPrimary = true, IsNullable = false)]
public uint ReasonId { get; set; }
[Column(Name = "is_index_deleted")]
public bool IsIndexDeleted { get; set; }
[Column(Name = "created_time")]
public DateTime CreatedTime { get; set; }
[Column(Name = "updated_time")]
public DateTime UpdatedTime { get; set; }
}
@@ -0,0 +1,43 @@
using FreeSql.DataAnnotations;
using System.Text.Json.Serialization;
namespace Store.Modules.CloudProduct.Entities
{
/// <summary>
/// 用户收藏商品表实体(对应数据库表 user_goods_favorites)
/// </summary>
[Table(Name = "user_goods_favorites")]
public class UserGoodsFavoriteEntity
{
/// <summary>
/// 自增主键
/// </summary>
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
[JsonIgnore]
public long Id { get; set; }
/// <summary>
/// 用户名(同一用户不能重复收藏同一商品)
/// </summary>
[Column(Name = "user_name", IsNullable = false, StringLength = 50)]
public string UserName { get; set; } = string.Empty;
/// <summary>
/// 收藏分组ID(0 表示默认分组),对应 user_goods_favorites_group.id
/// </summary>
[Column(Name = "group_id", IsNullable = false)]
public int GroupId { get; set; }
/// <summary>
/// 商品编号,对应 goods.goods_id
/// </summary>
[Column(Name = "goods_id", IsNullable = false)]
public long GoodsId { get; set; }
/// <summary>
/// 收藏时间
/// </summary>
[Column(Name = "created_at", IsNullable = false)]
public DateTime CreatedAt { get; set; }
}
}
@@ -0,0 +1,31 @@
using FreeSql.DataAnnotations;
using System.Text.Json.Serialization;
namespace Store.Modules.CloudProduct.Entities
{
/// <summary>
/// 用户收藏分组表实体(对应数据库表 user_goods_favorites_group)
/// </summary>
[Table(Name = "user_goods_favorites_group")]
public class UserGoodsFavoriteGroupEntity
{
/// <summary>
/// 自增主键,即收藏表 user_goods_favorites.group_id 的取值
/// </summary>
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
[JsonIgnore]
public long Id { get; set; }
/// <summary>
/// 用户名
/// </summary>
[Column(Name = "user_name", IsNullable = false, StringLength = 50)]
public string UserName { get; set; } = string.Empty;
/// <summary>
/// 分组名
/// </summary>
[Column(Name = "group_name", IsNullable = false, StringLength = 255)]
public string GroupName { get; set; } = string.Empty;
}
}
@@ -0,0 +1,16 @@
using FreeSql.DataAnnotations;
namespace Store.Modules.CloudProduct.Entities;
[Table(Name = "violation_reason")]
public class ViolationReasonEntity
{
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
public uint Id { get; set; }
[Column(Name = "name", StringLength = 100, IsNullable = false)]
public string Name { get; set; } = string.Empty;
[Column(Name = "is_violation", IsNullable = false)]
public bool IsViolation { get; set; }
}
@@ -0,0 +1,23 @@
namespace Store.Modules.CloudProduct.Enums
{
/// <summary>
/// 用户收藏商品搜索排序方式
/// </summary>
public enum UserFavoritesSortBy
{
/// <summary>按收藏时间倒序(默认)</summary>
CreatedTimeDesc = 0,
/// <summary>按收藏时间正序</summary>
CreatedTimeAsc = 1,
/// <summary>价格从低到高</summary>
PriceAsc = 2,
/// <summary>价格从高到低</summary>
PriceDesc = 3,
/// <summary>销量从高到低</summary>
SoldDesc = 4,
}
}
@@ -0,0 +1,118 @@
using FreeSql;
using MAX.Core.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Store.Modules.CloudProduct.Entities;
using Store.Modules.CloudProduct.Dtos;
namespace Store.Modules.CloudProduct.Repositorys;
public class GoodsViolationRepository(
[FromKeyedServices("CloudProductConnection")] IFreeSql fsql)
: BaseRepository<GoodsViolationEntity>(fsql), IScopedDependency
{
public Task<List<ViolationReasonDto>> GetReasonsAsync() => Orm.Select<ViolationReasonEntity>()
.OrderBy(x => x.Id).ToListAsync(x => new ViolationReasonDto
{
Name = x.Name,
IsViolation = x.IsViolation
});
public Task<List<long>> GetViolationIdsAsync(long[] ids) => Select
.Where(x => ids.Contains(x.GoodsId)).Distinct().ToListAsync(x => x.GoodsId);
public async Task<List<long>> GetOffShelfGoodsIdsAsync(long[] ids)
{
var records = await Select.Where(x => ids.Contains(x.GoodsId)).ToListAsync();
return records.GroupBy(x => x.GoodsId).Where(x => x.All(row => row.IsIndexDeleted))
.Select(x => x.Key).ToList();
}
// 解除违规和设置待同步必须一起提交,进程中断后后台索引任务仍可恢复。
public async Task<int> RemoveAndScheduleRestoreAsync(long[] ids)
{
using var unit = Orm.CreateUnitOfWork();
var violations = unit.GetRepository<GoodsViolationEntity>();
var goods = unit.GetRepository<GoodsEntity>();
var removedIds = await violations.Select.Where(x => ids.Contains(x.GoodsId)).Distinct().ToListAsync(x => x.GoodsId);
await violations.DeleteAsync(x => ids.Contains(x.GoodsId));
await goods.UpdateDiy.Set(x => x.IsSegmented, (byte)0)
.Where(x => ids.Contains(x.GoodsId) && x.Status == 0).ExecuteAffrowsAsync();
unit.Commit();
return removedIds.Count;
}
public Task<List<GoodsEntity>> GetRestorableGoodsAsync(long[] ids) => Orm.Select<GoodsEntity>()
.Where(x => ids.Contains(x.GoodsId) && x.Status == 0).ToListAsync();
public Task<int> MarkRestoredAsync(long[] ids) => Orm.Update<GoodsEntity>()
.Set(x => x.IsSegmented, (byte)1)
.Where(x => ids.Contains(x.GoodsId) && x.Status == 0).ExecuteAffrowsAsync();
// 调用方持有 GoodsIndexLock,事务内合并原因,避免并发覆盖。
public async Task<long[]> MergeAsync(Dictionary<long, string[]> items)
{
using var unit = Orm.CreateUnitOfWork();
var repository = unit.GetRepository<GoodsViolationEntity>();
var reasonRepository = unit.GetRepository<ViolationReasonEntity>();
var reasonIds = new Dictionary<string, uint>(StringComparer.Ordinal);
foreach (var name in items.Values.SelectMany(x => x).Distinct(StringComparer.Ordinal))
{
// 让数据库按字典表的排序规则匹配名称,与唯一索引保持一致。
var reason = await reasonRepository.Select.Where(x => x.Name == name).FirstAsync();
// 新类型只收录到字典,绝不因首次上报自动启用商品封禁。
reason ??= await reasonRepository.InsertAsync(new ViolationReasonEntity { Name = name, IsViolation = false });
// 数据库排序规则可能忽略部分字符差异;判定时仍要求名称完整相等。
if (reason.IsViolation && string.Equals(reason.Name, name, StringComparison.Ordinal))
reasonIds.Add(name, reason.Id);
}
var ids = items.Keys.ToArray();
var existing = (await repository.Select.Where(x => ids.Contains(x.GoodsId))
.ToListAsync()).ToLookup(x => x.GoodsId);
var now = DateTime.UtcNow;
var recordedIds = new List<long>();
foreach (var (goodsId, reasons) in items)
{
var accepted = reasons.Where(reasonIds.ContainsKey).Select(x => reasonIds[x]).Distinct().ToArray();
// 忽略原因仅记录字典,不新增或改变该商品已有的违规状态。
if (accepted.Length == 0) continue;
var rows = existing[goodsId].ToArray();
var previous = rows.Select(x => x.ReasonId).ToHashSet();
var added = accepted.Where(x => !previous.Contains(x)).ToArray();
if (added.Length == 0 && rows.All(x => x.IsIndexDeleted)) continue;
// 下架是商品级操作:新增原因或存在失败记录时,整件商品重新标记待下架。
foreach (var row in rows)
{
row.IsIndexDeleted = false;
row.UpdatedTime = now;
await repository.UpdateAsync(row);
}
foreach (var reasonId in added)
{
await repository.InsertAsync(new GoodsViolationEntity
{
GoodsId = goodsId, ReasonId = reasonId, IsIndexDeleted = false,
CreatedTime = now, UpdatedTime = now
});
}
recordedIds.Add(goodsId);
}
unit.Commit();
return recordedIds.ToArray();
}
public Task<int> MarkDeletedAsync(long[] ids) => Orm.Update<GoodsViolationEntity>()
.Set(x => x.IsIndexDeleted, true)
.Set(x => x.UpdatedTime, DateTime.UtcNow)
.Where(x => ids.Contains(x.GoodsId)).ExecuteAffrowsAsync();
public Task<List<long>> GetBatchAsync(long afterId, int size, bool pendingOnly) => Select
.Where(x => x.GoodsId > afterId)
.WhereIf(pendingOnly, x => !x.IsIndexDeleted)
.Distinct().OrderBy(x => x.GoodsId).Limit(size).ToListAsync(x => x.GoodsId);
public Task<List<long>> GetByReasonAsync(uint reasonId, long afterId, int size) => Select
.Where(x => x.ReasonId == reasonId)
.Where(x => x.GoodsId > afterId).OrderBy(x => x.GoodsId)
.Limit(size).ToListAsync(x => x.GoodsId);
}
@@ -0,0 +1,17 @@
using FreeSql;
using MAX.Core.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Store.Modules.CloudProduct.Entities;
namespace Store.Modules.CloudProduct.Repositorys
{
/// <summary>
/// 用户收藏分组仓储(对应 user_goods_favorites_group 表)
/// </summary>
public class UserGoodsFavoriteGroupRepository : BaseRepository<UserGoodsFavoriteGroupEntity>, IScopedDependency
{
public UserGoodsFavoriteGroupRepository([FromKeyedServices("CloudProductConnection")] IFreeSql fsql) : base(fsql)
{
}
}
}
@@ -0,0 +1,17 @@
using FreeSql;
using MAX.Core.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Store.Modules.CloudProduct.Entities;
namespace Store.Modules.CloudProduct.Repositorys
{
/// <summary>
/// 用户收藏商品仓储(对应 user_goods_favorites 表)
/// </summary>
public class UserGoodsFavoriteRepository : BaseRepository<UserGoodsFavoriteEntity>, IScopedDependency
{
public UserGoodsFavoriteRepository([FromKeyedServices("CloudProductConnection")] IFreeSql fsql) : base(fsql)
{
}
}
}
@@ -0,0 +1,41 @@
using MAX.Core.DependencyInjection;
using MAX.Framework.Commons;
using Microsoft.Extensions.Configuration;
using MySql.Data.MySqlClient;
using System.Security.Cryptography;
using System.Text;
namespace Store.Modules.CloudProduct.Services;
/// <summary>跨实例串行化违规上报和商品索引写入,防止下架后被旧批次写回。</summary>
public class GoodsIndexLock(IConfiguration configuration) : ISingletonDependency
{
public async Task<IAsyncDisposable> AcquireAsync()
{
// 禁用连接池:即使释放锁失败,关闭物理连接也会释放会话锁。
var settings = new MySqlConnectionStringBuilder(configuration["CloudProductConnection"])
{
Pooling = false
};
var connection = new MySqlConnection(settings.ConnectionString);
var name = "goods-index:" + Convert.ToHexString(SHA256.HashData(
Encoding.UTF8.GetBytes(settings.Database)))[..40];
try
{
await connection.OpenAsync();
using var command = connection.CreateCommand();
command.CommandText = "SELECT GET_LOCK(@name, 30)";
command.CommandTimeout = 35;
command.Parameters.AddWithValue("@name", name);
var result = await command.ExecuteScalarAsync();
if (result == null || result == DBNull.Value || Convert.ToInt32(result) != 1)
throw new AppException("商品索引正在处理,请稍后重试");
return connection;
}
catch
{
await connection.DisposeAsync();
throw;
}
}
}
@@ -23,9 +23,11 @@ namespace Store.Modules.CloudProduct.Services
private readonly IOpenSearchService _searchService; private readonly IOpenSearchService _searchService;
private readonly IRawDataStorage _rawDataStorage; private readonly IRawDataStorage _rawDataStorage;
private readonly IConfiguration _configuration; private readonly IConfiguration _configuration;
private readonly GoodsViolationService _violations;
public GoodsService(GoodsRepository repository, IOpenSearchService searchService, IRawDataStorage rawDataStorage, IConfiguration configuration) public GoodsService(GoodsRepository repository, IOpenSearchService searchService, IRawDataStorage rawDataStorage, IConfiguration configuration, GoodsViolationService violations)
{ {
_violations = violations;
_repository = repository; _repository = repository;
_searchService = searchService; _searchService = searchService;
_rawDataStorage = rawDataStorage; _rawDataStorage = rawDataStorage;
@@ -146,7 +148,6 @@ namespace Store.Modules.CloudProduct.Services
var indexImmediately = IsImmediateIndexing(); var indexImmediately = IsImmediateIndexing();
var documents = new List<GoodsSearchDocument>(); var documents = new List<GoodsSearchDocument>();
var indexedIds = new List<long>();
foreach (var item in items) foreach (var item in items)
{ {
@@ -194,7 +195,6 @@ namespace Store.Modules.CloudProduct.Services
MinPrice = saved.MinPrice, MinPrice = saved.MinPrice,
SoldQuantity = saved.SoldQuantity, SoldQuantity = saved.SoldQuantity,
}); });
indexedIds.Add(saved.GoodsId);
} }
result.SuccessCount++; result.SuccessCount++;
@@ -210,7 +210,7 @@ namespace Store.Modules.CloudProduct.Services
{ {
try try
{ {
await _searchService.BulkIndexGoodsAsync(documents); var indexedIds = await _searchService.BulkIndexGoodsAsync(documents);
await MarkIndexedAsync(indexedIds); await MarkIndexedAsync(indexedIds);
} }
catch (Exception ex) catch (Exception ex)
@@ -233,8 +233,9 @@ namespace Store.Modules.CloudProduct.Services
if (batchSize <= 0) if (batchSize <= 0)
batchSize = 200; batchSize = 200;
var pending = await _repository.Select var pending = await _repository.Select.As("g")
.Where(x => x.IsSegmented == 0 && x.Status == 0) .Where(x => x.IsSegmented == 0 && x.Status == 0)
.Where("NOT EXISTS (SELECT 1 FROM goods_violation v WHERE v.goods_id = g.goods_id)")
.OrderBy(x => x.GoodsId) .OrderBy(x => x.GoodsId)
.Limit(batchSize) .Limit(batchSize)
.ToListAsync(); .ToListAsync();
@@ -258,10 +259,9 @@ namespace Store.Modules.CloudProduct.Services
}) })
.ToList(); .ToList();
await _searchService.BulkIndexGoodsAsync(documents); var indexedIds = await _searchService.BulkIndexGoodsAsync(documents);
await MarkIndexedAsync(indexedIds);
await MarkIndexedAsync(pending.Select(x => x.GoodsId)); return indexedIds.Length;
return pending.Count;
} }
/// <summary> /// <summary>
@@ -308,22 +308,22 @@ namespace Store.Modules.CloudProduct.Services
/// </summary> /// </summary>
public async Task<long> RebuildSearchIndexAsync(IEnumerable<long>? ids = null) public async Task<long> RebuildSearchIndexAsync(IEnumerable<long>? ids = null)
{ {
List<GoodsEntity> goodsList; await _violations.DeleteViolationIndexesAsync(pendingOnly: false);
var idList = ids?.Distinct().ToArray() ?? [];
var idList = ids?.ToList(); long lastId = 0, count = 0;
if (idList == null || idList.Count == 0) while (true)
{ {
goodsList = await _repository.Select.ToListAsync(); var goodsList = await _repository.Select.As("g")
.Where(x => x.Status == 0 && x.GoodsId > 0 && x.Id > lastId)
.WhereIf(idList.Length > 0, x => idList.Contains(x.GoodsId))
.Where("NOT EXISTS (SELECT 1 FROM goods_violation v WHERE v.goods_id = g.goods_id)")
.OrderBy(x => x.Id).Limit(1000).ToListAsync();
if (goodsList.Count == 0) break;
var indexedIds = await _searchService.RebuildIndexAsync(goodsList);
await MarkIndexedAsync(indexedIds);
count += indexedIds.Length;
lastId = goodsList[^1].Id;
} }
else
{
goodsList = await _repository.Select
.Where(x => idList.Contains(x.GoodsId))
.ToListAsync();
}
var count = await _searchService.RebuildIndexAsync(goodsList);
await MarkIndexedAsync(goodsList.Where(x => x.GoodsId > 0).Select(x => x.GoodsId));
return count; return count;
} }
@@ -0,0 +1,13 @@
using Microsoft.Extensions.DependencyInjection;
namespace Store.Modules.CloudProduct.Services;
public class GoodsViolationIndexJob(IServiceScopeFactory scopeFactory)
{
public async Task ProcessPendingAsync()
{
using var scope = scopeFactory.CreateScope();
await scope.ServiceProvider.GetRequiredService<GoodsViolationService>()
.DeleteViolationIndexesAsync();
}
}
@@ -0,0 +1,124 @@
using MAX.Core.DependencyInjection;
using MAX.Framework.Commons;
using MAX.Framework.Dtos;
using Microsoft.Extensions.Logging;
using Store.Modules.CloudProduct.Dtos;
using Store.Modules.CloudProduct.Repositorys;
namespace Store.Modules.CloudProduct.Services;
public class GoodsViolationService(
GoodsViolationRepository repository,
GoodsIndexLock indexLock,
IOpenSearchService search,
ILogger<GoodsViolationService> logger) : IScopedDependency
{
public Task<List<ViolationReasonDto>> GetReasonsAsync() => repository.GetReasonsAsync();
public static Dictionary<long, string[]> ValidateAndGroup(ReportGoodsViolationItem[]? items)
{
if (items == null || items.Length is < 1 or > 1000)
throw new AppException("每次请提供1-1000条违规记录", ResultCode.ValidationError);
for (var i = 0; i < items.Length; i++)
{
var item = items[i];
if (item == null || item.GoodsId <= 0 || string.IsNullOrWhiteSpace(item.Reasons)
|| item.Reasons.Trim().Length > 100)
throw new AppException($"第{i + 1}条记录须提供有效商品编号和一个违规原因,原因去除首尾空白后须为1-100个字符", ResultCode.ValidationError);
}
return items.GroupBy(x => x.GoodsId).ToDictionary(x => x.Key,
x => x.Select(y => y.Reasons.Trim()).Distinct(StringComparer.Ordinal).ToArray());
}
public async Task<List<ReportGoodsViolationsResult>> ReportAsync(ReportGoodsViolationItem[]? items)
{
var grouped = ValidateAndGroup(items);
await using var lease = await indexLock.AcquireAsync();
var pendingIds = await repository.MergeAsync(grouped);
if (pendingIds.Length > 0)
{
try
{
await search.DeleteDocumentsAsync(pendingIds);
await repository.MarkDeletedAsync(pendingIds);
}
catch (Exception ex)
{
logger.LogError(ex, "违规记录已保存,{Count}个商品等待重试下架", pendingIds.Length);
}
}
// 返回商品当前持久化状态,包括本次原因被忽略但历史已下架的商品。
var offShelfIds = (await repository.GetOffShelfGoodsIdsAsync(grouped.Keys.ToArray())).ToHashSet();
return grouped.Keys.Select(id => new ReportGoodsViolationsResult
{
GoodsId = id,
IsOffShelf = offShelfIds.Contains(id)
}).ToList();
}
public async Task<List<GoodsViolationStatus>> GetStatusAsync(long[]? ids)
{
if (ids == null || ids.Length is < 1 or > 1000 || ids.Any(x => x <= 0))
throw new AppException("请提供1-1000个正数商品编号", ResultCode.ValidationError);
var distinct = ids.Distinct().ToArray();
var violations = (await repository.GetViolationIdsAsync(distinct)).ToHashSet();
return distinct.Select(x => new GoodsViolationStatus { GoodsId = x, IsViolation = violations.Contains(x) }).ToList();
}
public async Task<RemoveGoodsViolationsResult> RemoveAsync(long[]? ids)
{
if (ids == null || ids.Length is < 1 or > 1000 || ids.Any(x => x <= 0))
throw new AppException("请提供1-1000个正数商品编号", ResultCode.ValidationError);
var distinct = ids.Distinct().ToArray();
var result = new RemoveGoodsViolationsResult();
await using (var lease = await indexLock.AcquireAsync())
result.RemovedCount = await repository.RemoveAndScheduleRestoreAsync(distinct);
// 索引服务自行持锁并再次检查违规,避免与新的上报交错时重新上架违规商品。
var goods = await repository.GetRestorableGoodsAsync(distinct);
var candidates = goods.Select(x => x.GoodsId).Distinct().ToArray();
result.SkippedGoodsIds = distinct.Except(candidates).ToArray();
if (candidates.Length == 0) return result;
try
{
var restored = await search.RebuildIndexAsync(goods);
if (restored.Length > 0)
{
await using var lease = await indexLock.AcquireAsync();
var blocked = await repository.GetViolationIdsAsync(restored);
restored = restored.Except(blocked).ToArray();
if (restored.Length > 0) await repository.MarkRestoredAsync(restored);
}
result.RestoredGoodsIds = restored;
result.SkippedGoodsIds = distinct.Except(restored).ToArray();
}
catch (Exception ex)
{
logger.LogError(ex, "已解除违规,{Count}个商品等待后台任务恢复索引", candidates.Length);
result.PendingRestoreGoodsIds = candidates;
}
return result;
}
// 暂不注册 HTTP 路由。
public Task<List<long>> GetGoodsIdsByReasonAsync(uint reasonId, long afterGoodsId = 0, int pageSize = 100)
{
if (reasonId == 0 || afterGoodsId < 0 || pageSize is < 1 or > 1000)
throw new AppException("原因ID或分页参数无效", ResultCode.ValidationError);
return repository.GetByReasonAsync(reasonId, afterGoodsId, pageSize);
}
public async Task DeleteViolationIndexesAsync(bool pendingOnly = true)
{
long afterId = 0;
while (true)
{
await using var lease = await indexLock.AcquireAsync();
var ids = await repository.GetBatchAsync(afterId, 1000, pendingOnly);
if (ids.Count == 0) return;
await search.DeleteDocumentsAsync(ids);
await repository.MarkDeletedAsync(ids.ToArray());
afterId = ids[^1];
}
}
}
@@ -2,6 +2,7 @@ using System.Diagnostics;
using MAX.Core.DependencyInjection; using MAX.Core.DependencyInjection;
using MAX.Framework.Commons; using MAX.Framework.Commons;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using OpenSearch.Client; using OpenSearch.Client;
using OpenSearch.Net; using OpenSearch.Net;
@@ -14,7 +15,7 @@ namespace Store.Modules.CloudProduct.Services
public interface IOpenSearchService : ISingletonDependency public interface IOpenSearchService : ISingletonDependency
{ {
Task AddDocumentAsync(GoodsSearchDocument document); Task AddDocumentAsync(GoodsSearchDocument document);
Task BulkIndexGoodsAsync(IEnumerable<GoodsSearchDocument> documents); Task<long[]> BulkIndexGoodsAsync(IEnumerable<GoodsSearchDocument> documents);
Task<bool> ClearIndexAsync(); Task<bool> ClearIndexAsync();
Task<long> CountDocumentsAsync(); Task<long> CountDocumentsAsync();
Task<bool> CreateIndexAsync(); Task<bool> CreateIndexAsync();
@@ -24,7 +25,7 @@ namespace Store.Modules.CloudProduct.Services
Task<bool> IndexExistsAsync(); Task<bool> IndexExistsAsync();
Task<bool> IsIndexMappingHealthyAsync(); Task<bool> IsIndexMappingHealthyAsync();
Task RefreshIndexAsync(); Task RefreshIndexAsync();
Task<long> RebuildIndexAsync(IEnumerable<GoodsEntity> goodsList); Task<long[]> RebuildIndexAsync(IEnumerable<GoodsEntity> goodsList);
Task<(long Total, List<GoodsSearchDocument> Documents)> SearchByTitleAsync(GoodsSearchRequest request, GoodsSearchSortBy sortBy = GoodsSearchSortBy.Relevance); Task<(long Total, List<GoodsSearchDocument> Documents)> SearchByTitleAsync(GoodsSearchRequest request, GoodsSearchSortBy sortBy = GoodsSearchSortBy.Relevance);
} }
@@ -39,9 +40,14 @@ namespace Store.Modules.CloudProduct.Services
// 批量写入/建索引/删除索引等管理类操作超时(数据量大时需要更长,可挪到配置文件) // 批量写入/建索引/删除索引等管理类操作超时(数据量大时需要更长,可挪到配置文件)
private static readonly TimeSpan AdminTimeout = TimeSpan.FromSeconds(30); private static readonly TimeSpan AdminTimeout = TimeSpan.FromSeconds(30);
private readonly ILogger<OpenSearchService> _logger; private readonly ILogger<OpenSearchService> _logger;
private readonly IFreeSql _database;
private readonly GoodsIndexLock _indexLock;
public OpenSearchService(IConfiguration configuration,ILogger<OpenSearchService> logger) public OpenSearchService(IConfiguration configuration,ILogger<OpenSearchService> logger,
[FromKeyedServices("CloudProductConnection")] IFreeSql database, GoodsIndexLock indexLock)
{ {
_database = database;
_indexLock = indexLock;
var config = configuration.GetSection("Search"); var config = configuration.GetSection("Search");
_nodeUrl = config.GetValue<string>("Url") ?? ""; _nodeUrl = config.GetValue<string>("Url") ?? "";
_indexName = config.GetValue<string>("IndexName") ?? ""; _indexName = config.GetValue<string>("IndexName") ?? "";
@@ -204,12 +210,18 @@ namespace Store.Modules.CloudProduct.Services
/// <summary> /// <summary>
/// ============ 3.1 批量写入商品搜索文档(存在则覆盖) ============ /// ============ 3.1 批量写入商品搜索文档(存在则覆盖) ============
/// </summary> /// </summary>
public async Task BulkIndexGoodsAsync(IEnumerable<GoodsSearchDocument> documents) public async Task<long[]> BulkIndexGoodsAsync(IEnumerable<GoodsSearchDocument> documents)
{ {
if (documents == null) throw new ArgumentNullException(nameof(documents)); if (documents == null) throw new ArgumentNullException(nameof(documents));
var list = documents.ToList(); var list = documents.ToList();
if (list.Count == 0) return; if (list.Count == 0) return [];
await using var lease = await _indexLock.AcquireAsync();
var ids = list.Select(x => x.Id).Distinct().ToArray();
var blocked = (await _database.Select<GoodsViolationEntity>()
.Where(x => ids.Contains(x.GoodsId)).ToListAsync(x => x.GoodsId)).ToHashSet();
list = list.Where(x => !blocked.Contains(x.Id)).ToList();
if (list.Count == 0) return [];
// 确保索引已按 IK 分词映射创建,否则中文分词无效 // 确保索引已按 IK 分词映射创建,否则中文分词无效
await CreateIndexAsync(); await CreateIndexAsync();
@@ -220,19 +232,20 @@ namespace Store.Modules.CloudProduct.Services
.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)) .RequestConfiguration(r => r.RequestTimeout(AdminTimeout))
); );
if (!bulkResponse.IsValid) if (!bulkResponse.IsValid || bulkResponse.Errors)
{ {
throw new AppException("写入 OpenSearch 失败: " + bulkResponse.DebugInformation); throw new AppException("写入 OpenSearch 失败: " + bulkResponse.DebugInformation);
} }
// 刷新索引,保证数据立即可搜索(仅用于演示,生产环境不建议频繁 Refresh) // 刷新索引,保证数据立即可搜索(仅用于演示,生产环境不建议频繁 Refresh)
await RefreshIndexAsync(); await RefreshIndexAsync();
return list.Select(x => x.Id).Distinct().ToArray();
} }
/// <summary> /// <summary>
/// ============ 3.2 根据数据库商品重建搜索索引 ============ /// ============ 3.2 根据数据库商品重建搜索索引 ============
/// </summary> /// </summary>
public async Task<long> RebuildIndexAsync(IEnumerable<GoodsEntity> goodsList) public async Task<long[]> RebuildIndexAsync(IEnumerable<GoodsEntity> goodsList)
{ {
if (goodsList == null) throw new ArgumentNullException(nameof(goodsList)); if (goodsList == null) throw new ArgumentNullException(nameof(goodsList));
@@ -240,6 +253,8 @@ namespace Store.Modules.CloudProduct.Services
.Where(x => x != null && x.GoodsId > 0) .Where(x => x != null && x.GoodsId > 0)
.Select(x => new GoodsSearchDocument .Select(x => new GoodsSearchDocument
{ {
Platform = x.Platform,
ThumbUrl = x.ThumbUrl,
Id = x.GoodsId, Id = x.GoodsId,
Title = x.Title ?? string.Empty, Title = x.Title ?? string.Empty,
CatId1 = x.CatId1, CatId1 = x.CatId1,
@@ -251,10 +266,7 @@ namespace Store.Modules.CloudProduct.Services
}) })
.ToList(); .ToList();
if (documents.Count == 0) return 0; return await BulkIndexGoodsAsync(documents);
await BulkIndexGoodsAsync(documents);
return documents.Count;
} }
/// <summary> /// <summary>
@@ -269,7 +281,8 @@ namespace Store.Modules.CloudProduct.Services
.RequestConfiguration(r => r.RequestTimeout(QueryTimeout))); .RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
if (!exists.Exists) if (!exists.Exists)
{ {
return; if (exists.ApiCall?.HttpStatusCode == 404) return;
throw new AppException("检查 OpenSearch 索引失败: " + exists.DebugInformation);
} }
var response = await _client.BulkAsync(b => var response = await _client.BulkAsync(b =>
@@ -282,7 +295,9 @@ namespace Store.Modules.CloudProduct.Services
return b; return b;
}); });
if (!response.IsValid) if (response.ApiCall?.HttpStatusCode is not (>= 200 and < 300)
|| response.Items.Count != list.Count
|| response.Items.Any(x => x.Status != 404 && (x.Error != null || x.Status < 200 || x.Status >= 300)))
{ {
throw new AppException("删除 OpenSearch 文档失败: " + response.DebugInformation); throw new AppException("删除 OpenSearch 文档失败: " + response.DebugInformation);
} }
@@ -296,6 +311,9 @@ namespace Store.Modules.CloudProduct.Services
public async Task AddDocumentAsync(GoodsSearchDocument document) public async Task AddDocumentAsync(GoodsSearchDocument document)
{ {
if (document == null) throw new ArgumentNullException(nameof(document)); if (document == null) throw new ArgumentNullException(nameof(document));
await using var lease = await _indexLock.AcquireAsync();
if (await _database.Select<GoodsViolationEntity>().AnyAsync(x => x.GoodsId == document.Id))
throw new AppException("违规商品不能写入搜索索引");
var response = await _client.IndexAsync(document, i => i var response = await _client.IndexAsync(document, i => i
.Index(_indexName) .Index(_indexName)
@@ -522,6 +540,7 @@ namespace Store.Modules.CloudProduct.Services
/// </summary> /// </summary>
public async Task<bool> ClearIndexAsync() public async Task<bool> ClearIndexAsync()
{ {
await using var lease = await _indexLock.AcquireAsync();
var existsResponse = await _client.Indices.ExistsAsync(_indexName, d => d var existsResponse = await _client.Indices.ExistsAsync(_indexName, d => d
.RequestConfiguration(r => r.RequestTimeout(QueryTimeout))); .RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
if (!existsResponse.Exists) if (!existsResponse.Exists)
@@ -539,7 +558,10 @@ namespace Store.Modules.CloudProduct.Services
} }
Console.WriteLine($"索引 {_indexName} 已删除"); Console.WriteLine($"索引 {_indexName} 已删除");
return await CreateIndexAsync(); var created = await CreateIndexAsync();
await _database.Update<GoodsEntity>().Set(x => x.IsSegmented, (byte)0)
.Where(x => x.Status == 0).ExecuteAffrowsAsync();
return created;
} }
} }
} }
@@ -0,0 +1,420 @@
using MAX.Core.DependencyInjection;
using MAX.Framework.Commons;
using MAX.Framework.Dtos;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using OpenSearch.Client;
using OpenSearch.Net;
using Store.Modules.CloudProduct.Dtos;
using Store.Modules.CloudProduct.Enums;
namespace Store.Modules.CloudProduct.Services
{
/// <summary>
/// 用户收藏商品索引服务:负责收藏索引(Search:FavoritesIndexName)的
/// 创建、写入、删除、重建与检索,索引文档由 user_goods_favorites 关联 goods 补全而来。
/// </summary>
public interface IUserFavoritesIndexService : ISingletonDependency
{
/// <summary>检查索引是否存在</summary>
Task<bool> IndexExistsAsync();
/// <summary>检查索引映射(分析器)是否符合当前服务要求</summary>
Task<bool> IsIndexMappingHealthyAsync();
/// <summary>创建索引(含 IK 分词映射;已存在且映射正常时跳过)</summary>
Task<bool> CreateIndexAsync();
/// <summary>删除并重建索引(映射统一,重建期间该索引不可查)</summary>
Task<bool> ClearIndexAsync();
/// <summary>批量写入收藏文档(存在则覆盖)</summary>
Task IndexDocumentsAsync(IEnumerable<UserFavoritesSearchDocument> documents);
/// <summary>按文档Id批量删除收藏文档</summary>
Task DeleteDocumentsAsync(IEnumerable<string> documentIds);
/// <summary>统计索引文档数</summary>
Task<long> CountDocumentsAsync();
/// <summary>按用户检索收藏商品(标题/销量/价格/类目/分组)</summary>
Task<(long Total, List<UserFavoritesSearchDocument> Documents)> SearchAsync(UserFavoritesSearchRequest request, UserFavoritesSortBy sortBy);
}
internal class UserFavoritesIndexService : IUserFavoritesIndexService
{
private readonly string _nodeUrl;
private readonly string _indexName;
private readonly IOpenSearchClient _client = null!;
private readonly ILogger<UserFavoritesIndexService> _logger;
// 查询类操作(search/count/exists)统一超时
private static readonly TimeSpan QueryTimeout = TimeSpan.FromSeconds(5);
// 批量写入/建索引/删除索引等管理类操作超时(数据量大时需要更长)
private static readonly TimeSpan AdminTimeout = TimeSpan.FromSeconds(30);
public UserFavoritesIndexService(IConfiguration configuration, ILogger<UserFavoritesIndexService> logger)
{
var config = configuration.GetSection("Search");
_nodeUrl = config.GetValue<string>("Url") ?? "";
_indexName = config.GetValue<string>("FavoritesIndexName") ?? "";
_logger = logger;
_client = CreateClient();
}
private IOpenSearchClient CreateClient()
{
var pool = new SingleNodeConnectionPool(new Uri(_nodeUrl));
var settings = new ConnectionSettings(pool)
.DefaultIndex(_indexName)
.DefaultMappingFor<UserFavoritesSearchDocument>(m => m.IndexName(_indexName))
.RequestTimeout(QueryTimeout)
.MaxRetryTimeout(QueryTimeout)
.PrettyJson()
.DisableDirectStreaming();
return new OpenSearchClient(settings);
}
/// <summary>
/// ============ 1. 索引是否存在 ============
/// </summary>
public async Task<bool> IndexExistsAsync()
{
var response = await _client.Indices.ExistsAsync(_indexName, d => d
.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
return response.Exists;
}
/// <summary>
/// ============ 2. 索引映射是否健康 ============
/// </summary>
public async Task<bool> IsIndexMappingHealthyAsync()
{
var getResponse = await _client.Indices.GetAsync(_indexName, d => d
.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
if (!getResponse.IsValid)
{
throw new AppException("读取收藏索引映射失败: " + getResponse.DebugInformation);
}
if (!getResponse.Indices.TryGetValue(_indexName, out var indexState))
{
return false;
}
var mapping = indexState.Mappings;
if (mapping?.Properties == null
|| !mapping.Properties.TryGetValue(new PropertyName("title"), out var property)
|| property is not ITextProperty textProperty)
{
return false;
}
var indexAnalyzer = textProperty.Analyzer;
var searchAnalyzer = textProperty.SearchAnalyzer;
var usesIk = indexAnalyzer == "ik_max_word" && searchAnalyzer == "ik_smart";
var usesStandard = indexAnalyzer == "standard" && searchAnalyzer == "standard";
return usesIk || usesStandard;
}
/// <summary>
/// ============ 3. 创建索引 ============
/// </summary>
public async Task<bool> CreateIndexAsync()
{
var existsResponse = await _client.Indices.ExistsAsync(_indexName, d => d
.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
if (existsResponse.Exists)
{
if (await IsIndexMappingHealthyAsync())
{
return true;
}
_logger.LogWarning("收藏索引 [{Index}] 的映射不完整,正在重建...", _indexName);
var deleteResponse = await _client.Indices.DeleteAsync(_indexName, d => d
.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
if (!deleteResponse.IsValid)
{
throw new AppException("删除损坏的收藏索引失败: " + deleteResponse.DebugInformation);
}
}
// 优先尝试使用 IK 中文分词(需集群安装 analysis-ik 插件)
var createResponse = await TryCreateIndexAsync(useIk: true);
if (!createResponse.IsValid)
{
_logger.LogWarning("IK 分词插件不可用,收藏索引已回退到 standard 分析器,中文分词将失效。");
createResponse = await TryCreateIndexAsync(useIk: false);
}
if (!createResponse.IsValid)
{
throw new AppException("收藏索引创建失败: " + createResponse.DebugInformation);
}
_logger.LogInformation("收藏索引 [{Index}] 创建成功。", _indexName);
return true;
}
private async Task<CreateIndexResponse> TryCreateIndexAsync(bool useIk)
{
var indexAnalyzer = useIk ? "ik_max_word" : "standard";
var searchAnalyzer = useIk ? "ik_smart" : "standard";
return await _client.Indices.CreateAsync(_indexName, c => c
.Settings(s => s
.NumberOfShards(1)
.NumberOfReplicas(0)
)
.Map<UserFavoritesSearchDocument>(m => m
.Properties(p => p
.Keyword(k => k.Name(x => x.Id))
.Number(n => n.Name(x => x.FavId).Type(NumberType.Long))
.Keyword(k => k.Name(x => x.UserName))
.Number(n => n.Name(x => x.GroupId).Type(NumberType.Integer))
.Keyword(k => k.Name(x => x.GroupName))
.Number(n => n.Name(x => x.GoodsId).Type(NumberType.Long))
.Number(n => n.Name(x => x.Platform).Type(NumberType.Byte))
.Text(t => t
.Name(x => x.Title)
.Analyzer(indexAnalyzer)
.SearchAnalyzer(searchAnalyzer)
)
.Text(t => t.Name(x => x.ThumbUrl))
.Number(n => n.Name(x => x.CatId1).Type(NumberType.Integer))
.Number(n => n.Name(x => x.CatId2).Type(NumberType.Integer))
.Number(n => n.Name(x => x.CatId3).Type(NumberType.Integer))
.Number(n => n.Name(x => x.CatId4).Type(NumberType.Integer))
.Number(n => n.Name(x => x.MinPrice).Type(NumberType.Long))
.Number(n => n.Name(x => x.SoldQuantity).Type(NumberType.Integer))
.Date(d => d.Name(x => x.CreatedAt))
)
)
.RequestConfiguration(r => r.RequestTimeout(AdminTimeout))
);
}
/// <summary>
/// ============ 4. 删除并重建索引 ============
/// </summary>
public async Task<bool> ClearIndexAsync()
{
var existsResponse = await _client.Indices.ExistsAsync(_indexName, d => d
.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
if (!existsResponse.Exists)
{
return await CreateIndexAsync();
}
var deleteResponse = await _client.Indices.DeleteAsync(_indexName, d => d
.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
if (!deleteResponse.IsValid)
{
throw new AppException($"删除收藏索引 {_indexName} 失败: " + deleteResponse.DebugInformation);
}
_logger.LogInformation("收藏索引 [{Index}] 已删除,准备重建。", _indexName);
return await CreateIndexAsync();
}
private async Task RefreshIndexAsync()
{
var response = await _client.Indices.RefreshAsync(_indexName, d => d
.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
if (!response.IsValid)
{
throw new AppException("刷新收藏索引失败: " + response.DebugInformation);
}
}
/// <summary>
/// ============ 5. 批量写入收藏文档(存在则覆盖) ============
/// </summary>
public async Task IndexDocumentsAsync(IEnumerable<UserFavoritesSearchDocument> documents)
{
if (documents == null) throw new ArgumentNullException(nameof(documents));
var list = documents.Where(x => x != null && string.IsNullOrWhiteSpace(x.Id) == false).ToList();
if (list.Count == 0) return;
await CreateIndexAsync();
var bulkResponse = await _client.BulkAsync(b => b
.Index(_indexName)
.IndexMany(list, (descriptor, doc) => descriptor.Id(doc.Id))
.RequestConfiguration(r => r.RequestTimeout(AdminTimeout))
);
if (!bulkResponse.IsValid)
{
throw new AppException("批量写入收藏索引失败: " + bulkResponse.DebugInformation);
}
await RefreshIndexAsync();
}
/// <summary>
/// ============ 6. 按文档Id批量删除收藏文档 ============
/// </summary>
public async Task DeleteDocumentsAsync(IEnumerable<string> documentIds)
{
var list = documentIds?.Where(x => string.IsNullOrWhiteSpace(x) == false).Distinct().ToList() ?? new List<string>();
if (list.Count == 0) return;
if (await IndexExistsAsync() == false)
{
return;
}
var response = await _client.BulkAsync(b =>
{
foreach (var id in list)
{
b.Delete<UserFavoritesSearchDocument>(d => d.Index(_indexName).Id(id));
}
b.RequestConfiguration(r => r.RequestTimeout(AdminTimeout));
return b;
});
if (!response.IsValid)
{
throw new AppException("删除收藏索引文档失败: " + response.DebugInformation);
}
await RefreshIndexAsync();
}
/// <summary>
/// ============ 7. 统计文档数 ============
/// </summary>
public async Task<long> CountDocumentsAsync()
{
var countResponse = await _client.CountAsync<UserFavoritesSearchDocument>(c => c
.Index(_indexName)
.RequestConfiguration(r => r.RequestTimeout(QueryTimeout))
);
if (!countResponse.IsValid)
{
throw new AppException("统计收藏索引失败: " + countResponse.DebugInformation);
}
return countResponse.Count;
}
/// <summary>
/// ============ 8. 检索用户收藏商品(标题/价格/销量/类目/分组 + 排序 + 分页) ============
/// </summary>
public async Task<(long Total, List<UserFavoritesSearchDocument> Documents)> SearchAsync(UserFavoritesSearchRequest request, UserFavoritesSortBy sortBy)
{
if (request == null) throw new ArgumentNullException(nameof(request));
if (string.IsNullOrWhiteSpace(request.UserName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
var keyword = request.Title;
int? groupId = request.GroupId;
var groupName = request.GroupName;
int pageIndex = request.PageIndex;
int pageSize = request.PageSize;
if (pageIndex < 1) pageIndex = 1;
if (pageSize < 1) pageSize = 20;
if (pageSize > 2000) pageSize = 2000; // 避免深分页/单页过大拖垮性能
var from = (pageIndex - 1) * pageSize;
ISearchResponse<UserFavoritesSearchDocument> searchResponse;
try
{
searchResponse = await _client.SearchAsync<UserFavoritesSearchDocument>(s => s
.Index(_indexName)
.Query(q => q
.Bool(b =>
{
var filters = new List<Func<QueryContainerDescriptor<UserFavoritesSearchDocument>, QueryContainer>>();
// 只检索当前用户自己的收藏 —— 放进 filters,避免被后面的 Filter 覆盖
filters.Add(f => f.Term(t => t.Field(x => x.UserName).Value(request.UserName)));
if (groupId.HasValue)
{
filters.Add(f => f.Term(t => t.Field(x => x.GroupId).Value(groupId.Value)));
}
else if (string.IsNullOrWhiteSpace(groupName) == false)
{
filters.Add(f => f.Term(t => t.Field(x => x.GroupName).Value(groupName)));
}
if (request.Platform.HasValue && request.Platform.Value > 0)
{
filters.Add(f => f.Term(t => t.Field(x => x.Platform).Value(request.Platform.Value)));
}
if (request.CatId1.HasValue) filters.Add(f => f.Term(t => t.Field(x => x.CatId1).Value(request.CatId1.Value)));
if (request.CatId2.HasValue) filters.Add(f => f.Term(t => t.Field(x => x.CatId2).Value(request.CatId2.Value)));
if (request.CatId3.HasValue) filters.Add(f => f.Term(t => t.Field(x => x.CatId3).Value(request.CatId3.Value)));
if (request.CatId4.HasValue) filters.Add(f => f.Term(t => t.Field(x => x.CatId4).Value(request.CatId4.Value)));
if (request.MinPrice.HasValue || request.MaxPrice.HasValue)
{
filters.Add(f => f.Range(r =>
{
var range = r.Field(x => x.MinPrice);
if (request.MinPrice.HasValue) range = range.GreaterThanOrEquals(request.MinPrice.Value);
if (request.MaxPrice.HasValue) range = range.LessThanOrEquals(request.MaxPrice.Value);
return range;
}));
}
if (request.MinSoldQuantity.HasValue || request.MaxSoldQuantity.HasValue)
{
filters.Add(f => f.Range(r =>
{
var range = r.Field(x => x.SoldQuantity);
if (request.MinSoldQuantity.HasValue) range = range.GreaterThanOrEquals(request.MinSoldQuantity.Value);
if (request.MaxSoldQuantity.HasValue) range = range.LessThanOrEquals(request.MaxSoldQuantity.Value);
return range;
}));
}
// 统一一次性应用所有 filter,避免覆盖
b.Filter(filters.ToArray());
if (string.IsNullOrWhiteSpace(keyword) == false)
{
b.Must(m => m.Match(mm => mm.Field(f => f.Title).Query(keyword)));
}
return b;
})
)
.Sort(sort => sortBy switch
{
UserFavoritesSortBy.CreatedTimeAsc => sort.Ascending(f => f.CreatedAt),
UserFavoritesSortBy.PriceAsc => sort.Ascending(f => f.MinPrice),
UserFavoritesSortBy.PriceDesc => sort.Descending(f => f.MinPrice),
UserFavoritesSortBy.SoldDesc => sort.Descending(f => f.SoldQuantity),
_ => sort.Descending(f => f.CreatedAt)
})
.From(from)
.Size(pageSize)
.TrackTotalHits(true)
.RequestConfiguration(r => r.RequestTimeout(QueryTimeout))
);}
catch (OpenSearchClientException ex) when (ex.Response?.Success == false)
{
throw new AppException($"收藏检索超时或失败({QueryTimeout.TotalSeconds}秒): " + ex.Message);
}
if (!searchResponse.IsValid)
{
throw new AppException("收藏检索失败: " + searchResponse.DebugInformation);
}
return (searchResponse.Total, searchResponse.Documents.ToList());
}
}
}
@@ -0,0 +1,603 @@
using MAX.Core.DependencyInjection;
using MAX.Framework.Commons;
using MAX.Framework.Dtos;
using Microsoft.Extensions.Logging;
using Store.Modules.CloudProduct.Dtos;
using Store.Modules.CloudProduct.Entities;
using Store.Modules.CloudProduct.Enums;
using Store.Modules.CloudProduct.Repositorys;
namespace Store.Modules.CloudProduct.Services
{
/// <summary>
/// 用户收藏商品业务:收藏/取消收藏(数据库 + 收藏索引同步写入)、收藏分组维护、收藏状态查询、收藏检索与索引重建。
/// </summary>
public interface IUserFavoritesService : IScopedDependency
{
/// <summary>批量收藏商品,返回本次成功收藏的商品数量(已收藏的商品视为修改收藏分组)</summary>
Task<int> AddFavoritesAsync(AddUserFavoriteRequest request);
/// <summary>批量取消收藏,返回实际取消的条数</summary>
Task<int> RemoveFavoritesAsync(RemoveUserFavoritesRequest request);
/// <summary>创建收藏分组:创建成功返回 true,同名分组已存在返回 false</summary>
Task<bool> CreateGroupAsync(CreateUserFavoriteGroupRequest request);
/// <summary>查询用户的收藏分组(含默认分组)及分组下收藏数量</summary>
Task<List<UserFavoriteGroupDto>> GetGroupsAsync(string userName);
/// <summary>按 GoodsIds 顺序返回每个商品是否已被该用户收藏</summary>
Task<List<bool>> GetFavoriteStatusAsync(UserFavoriteStatusRequest request);
/// <summary>检索用户收藏的商品(标题/销量/价格/类目/分组)</summary>
Task<(List<UserFavoriteItem> List, long Total)> SearchFavoritesAsync(UserFavoritesSearchRequest request);
/// <summary>移除所有用户收藏索引并按数据库数据全量重建,返回重建的文档数</summary>
Task<long> RebuildSearchIndexAsync();
}
internal class UserFavoritesService : IUserFavoritesService
{
/// <summary>未归属任何分组的收藏所使用的分组名(对应 group_id = 0)</summary>
public const string DefaultGroupName = "默认分组";
/// <summary>重建索引时单次 bulk 的文档数,避免一次请求过大</summary>
private const int RebuildBatchSize = 2000;
private readonly UserGoodsFavoriteRepository _favoriteRepository;
private readonly UserGoodsFavoriteGroupRepository _groupRepository;
private readonly GoodsRepository _goodsRepository;
private readonly IUserFavoritesIndexService _indexService;
private readonly ILogger<UserFavoritesService> _logger;
public UserFavoritesService(
UserGoodsFavoriteRepository favoriteRepository,
UserGoodsFavoriteGroupRepository groupRepository,
GoodsRepository goodsRepository,
IUserFavoritesIndexService indexService,
ILogger<UserFavoritesService> logger)
{
_favoriteRepository = favoriteRepository;
_groupRepository = groupRepository;
_goodsRepository = goodsRepository;
_indexService = indexService;
_logger = logger;
}
/// <summary>
/// 批量收藏商品:先落库(user_goods_favorites),再同步写入收藏索引;
/// 商品不存在/已删除的编号会被跳过,返回本次成功收藏的商品数量。
/// 任意一步失败都会回滚本次已写入的数据库记录,保证“数据库中有收藏 = 索引中可搜索到”。
/// </summary>
public async Task<int> AddFavoritesAsync(AddUserFavoriteRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
var userName = request.UserName?.Trim() ?? string.Empty;
if (string.IsNullOrWhiteSpace(userName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
var goodsIds = request.GoodsIds?.Where(x => x > 0).Distinct().ToList() ?? new List<long>();
if (goodsIds.Count == 0)
{
throw new AppException("请提供要收藏的商品编号", ResultCode.ValidationError);
}
if (request.GroupId < 0)
{
throw new AppException("收藏分组无效", ResultCode.ValidationError);
}
// 1. 校验分组归属(分组ID > 0 时必须是该用户自己创建的分组)
if (request.GroupId > 0)
{
var group = await _groupRepository.Select
.Where(x => x.Id == request.GroupId && x.UserName == userName)
.FirstAsync();
if (group == null)
{
throw new AppException($"收藏分组不存在: {request.GroupId}", ResultCode.ValidationError);
}
}
var groupName = await ResolveGroupNameAsync(userName, request.GroupId);
// 2. 批量取商品快照(不存在/已删除的商品不收藏,直接跳过)
var goodsList = await _goodsRepository.Select
.Where(x => goodsIds.Contains(x.GoodsId) && x.Status == 0)
.ToListAsync();
if (goodsList.Count == 0)
{
return 0;
}
var goodsMap = new Dictionary<long, GoodsEntity>();
foreach (var goods in goodsList)
{
goodsMap[goods.GoodsId] = goods;
}
// 3. 批量取已存在的收藏记录
var existingList = await _favoriteRepository.Select
.Where(x => x.UserName == userName && goodsIds.Contains(x.GoodsId))
.ToListAsync();
var existingMap = new Dictionary<long, UserGoodsFavoriteEntity>();
foreach (var favorite in existingList)
{
existingMap[favorite.GoodsId] = favorite;
}
// 4. 逐条落库:不存在则新增,已存在且分组不同则修改分组
var insertedIds = new List<long>();
var changedGroupIds = new List<(long Id, int PreviousGroupId)>();
var documents = new List<UserFavoritesSearchDocument>();
try
{
foreach (var goods in goodsMap.Values)
{
if (existingMap.TryGetValue(goods.GoodsId, out var favorite) == false)
{
favorite = new UserGoodsFavoriteEntity
{
UserName = userName,
GoodsId = goods.GoodsId,
GroupId = request.GroupId,
CreatedAt = DateTime.Now,
};
try
{
await _favoriteRepository.InsertAsync(favorite);
insertedIds.Add(favorite.Id);
}
catch (Exception ex)
{
// 并发收藏同一商品时可能命中唯一键 uk_user_goods,回读已存在记录后按“修改分组”处理
favorite = await _favoriteRepository.Select
.Where(x => x.UserName == userName && x.GoodsId == goods.GoodsId)
.FirstAsync();
if (favorite == null)
{
throw new AppException($"收藏商品失败({goods.GoodsId}): {ex.Message}");
}
}
}
if (favorite.GroupId != request.GroupId)
{
changedGroupIds.Add((favorite.Id, favorite.GroupId));
await _favoriteRepository.Orm.Update<UserGoodsFavoriteEntity>()
.Set(x => x.GroupId, request.GroupId)
.Where(x => x.Id == favorite.Id)
.ExecuteAffrowsAsync();
favorite.GroupId = request.GroupId;
}
documents.Add(BuildDocument(favorite, goods, groupName));
}
}
catch
{
await CompensateWriteFailureAsync(insertedIds, changedGroupIds);
throw;
}
// 5. 批量同步写入索引
try
{
await _indexService.IndexDocumentsAsync(documents);
}
catch
{
await CompensateWriteFailureAsync(insertedIds, changedGroupIds);
throw;
}
return documents.Count;
}
/// <summary>
/// 批量取消收藏:先删除数据库记录,再删除索引文档;
/// 索引删除失败时回补数据库记录,避免“库里有收藏但搜索不到”。
/// </summary>
public async Task<int> RemoveFavoritesAsync(RemoveUserFavoritesRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
var userName = request.UserName?.Trim() ?? string.Empty;
if (string.IsNullOrWhiteSpace(userName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
var goodsIds = request.GoodsIds?.Where(x => x > 0).Distinct().ToList() ?? new List<long>();
if (goodsIds.Count == 0)
{
throw new AppException("请提供要取消收藏的商品编号", ResultCode.ValidationError);
}
var favorites = await _favoriteRepository.Select
.Where(x => x.UserName == userName && goodsIds.Contains(x.GoodsId))
.ToListAsync();
if (favorites.Count == 0)
{
return 0;
}
await _favoriteRepository.Orm.Delete<UserGoodsFavoriteEntity>()
.Where(x => x.UserName == userName && goodsIds.Contains(x.GoodsId))
.ExecuteAffrowsAsync();
try
{
await _indexService.DeleteDocumentsAsync(
favorites.Select(x => UserFavoritesSearchDocument.BuildId(x.UserName, x.GoodsId)));
}
catch (Exception ex)
{
// 索引删除失败:回补数据库记录(自增主键会重新生成,检索以“用户名+商品编号”为准,不受影响)
_logger.LogError(ex, "删除收藏索引失败,回补数据库收藏记录。UserName={UserName} Count={Count}", userName, favorites.Count);
await _favoriteRepository.InsertAsync(favorites);
throw;
}
return favorites.Count;
}
/// <summary>
/// 创建收藏分组:创建成功返回 true,同一用户同名分组已存在返回 false。
/// </summary>
public async Task<bool> CreateGroupAsync(CreateUserFavoriteGroupRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
var userName = request.UserName?.Trim() ?? string.Empty;
if (string.IsNullOrWhiteSpace(userName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
var groupName = request.GroupName?.Trim() ?? string.Empty;
if (string.IsNullOrWhiteSpace(groupName))
{
throw new AppException("分组名不能为空", ResultCode.ValidationError);
}
if (groupName.Length > 255)
{
throw new AppException("分组名长度不能超过255个字符", ResultCode.ValidationError);
}
var existing = await _groupRepository.Select
.Where(x => x.UserName == userName && x.GroupName == groupName)
.FirstAsync();
if (existing != null)
{
return false;
}
await _groupRepository.InsertAsync(new UserGoodsFavoriteGroupEntity
{
UserName = userName,
GroupName = groupName,
});
return true;
}
/// <summary>
/// 查询用户的收藏分组及分组下收藏数量,默认分组(分组ID=0)存在收藏时一并返回。
/// </summary>
public async Task<List<UserFavoriteGroupDto>> GetGroupsAsync(string userName)
{
userName = userName?.Trim() ?? string.Empty;
if (string.IsNullOrWhiteSpace(userName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
var groups = await _groupRepository.Select
.Where(x => x.UserName == userName)
.OrderBy(x => x.Id)
.ToListAsync();
var countList = await _favoriteRepository.Select
.Where(x => x.UserName == userName)
.GroupBy(x => x.GroupId)
.ToListAsync(x => new { GroupId = x.Key, Count = x.Count() });
var countMap = countList.ToDictionary(x => x.GroupId, x => (long)x.Count);
var result = new List<UserFavoriteGroupDto>();
if (countMap.TryGetValue(0, out var defaultCount) && defaultCount > 0)
{
result.Add(new UserFavoriteGroupDto
{
Id = 0,
UserName = userName,
GroupName = DefaultGroupName,
FavoriteCount = defaultCount,
});
}
result.AddRange(groups.Select(x => new UserFavoriteGroupDto
{
Id = x.Id,
UserName = x.UserName,
GroupName = x.GroupName,
FavoriteCount = countMap.TryGetValue((int)x.Id, out var count) ? count : 0,
}));
return result;
}
/// <summary>
/// 按 GoodsIds 顺序返回每个商品是否已被该用户收藏(商品编号无效的返回 false)。
/// 以数据库为准,不依赖索引,索引重建期间结果依然准确。
/// </summary>
public async Task<List<bool>> GetFavoriteStatusAsync(UserFavoriteStatusRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
var userName = request.UserName?.Trim() ?? string.Empty;
if (string.IsNullOrWhiteSpace(userName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
var goodsIds = request.GoodsIds ?? new List<long>();
if (goodsIds.Count == 0)
{
return new List<bool>();
}
var validIds = goodsIds.Where(x => x > 0).Distinct().ToList();
var favoritedIds = new HashSet<long>();
if (validIds.Count > 0)
{
var favorited = await _favoriteRepository.Select
.Where(x => x.UserName == userName && validIds.Contains(x.GoodsId))
.ToListAsync(x => x.GoodsId);
favoritedIds = favorited.ToHashSet();
}
// 结果与入参顺序一一对应,前台可直接按下标渲染
return goodsIds.Select(x => x > 0 && favoritedIds.Contains(x)).ToList();
}
/// <summary>
/// 从收藏索引检索当前用户的收藏商品。
/// </summary>
public async Task<(List<UserFavoriteItem> List, long Total)> SearchFavoritesAsync(UserFavoritesSearchRequest request)
{
if (request == null)
{
throw new AppException("请求参数不能为空", ResultCode.ValidationError);
}
var userName = request.UserName?.Trim() ?? string.Empty;
if (string.IsNullOrWhiteSpace(userName))
{
throw new AppException("用户名不能为空", ResultCode.ValidationError);
}
request.UserName = userName;
var searchResult = await _indexService.SearchAsync(request, ParseSortBy(request.SortBy));
var list = searchResult.Documents.Select(ToItem).ToList();
return (list, searchResult.Total);
}
/// <summary>
/// 移除所有用户收藏索引并重新创建,然后从 user_goods_favorites 关联 goods 全量回填。
/// </summary>
public async Task<long> RebuildSearchIndexAsync()
{
// 1. 删除并重建索引(清空所有用户收藏索引)
await _indexService.ClearIndexAsync();
// 2. 从数据库读取全部收藏记录
var favorites = await _favoriteRepository.Select
.OrderBy(x => x.Id)
.ToListAsync();
if (favorites.Count == 0)
{
return 0;
}
// 3. 关联 goods 补全商品数据(标题/价格/销量/类目/平台/缩略图)
var goodsIds = favorites.Select(x => x.GoodsId).Distinct().ToList();
var goodsList = await _goodsRepository.Select
.Where(x => goodsIds.Contains(x.GoodsId))
.ToListAsync();
var goodsMap = new Dictionary<long, GoodsEntity>();
foreach (var goods in goodsList)
{
goodsMap[goods.GoodsId] = goods;
}
// 4. 关联分组表补全分组名
var groupIds = favorites.Where(x => x.GroupId > 0).Select(x => (long)x.GroupId).Distinct().ToList();
var groupMap = new Dictionary<int, string>();
if (groupIds.Count > 0)
{
var groups = await _groupRepository.Select
.Where(x => groupIds.Contains(x.Id))
.ToListAsync();
foreach (var group in groups)
{
groupMap[(int)group.Id] = group.GroupName;
}
}
var documents = new List<UserFavoritesSearchDocument>();
var missingGoodsCount = 0;
foreach (var favorite in favorites)
{
if (goodsMap.TryGetValue(favorite.GoodsId, out var goods) == false)
{
// 商品已被物理删除,跳过该收藏(不写入索引)
missingGoodsCount++;
continue;
}
var groupName = favorite.GroupId <= 0
? DefaultGroupName
: (groupMap.TryGetValue(favorite.GroupId, out var name) ? name : string.Empty);
documents.Add(BuildDocument(favorite, goods, groupName));
}
// 5. 分批写入索引
for (var offset = 0; offset < documents.Count; offset += RebuildBatchSize)
{
await _indexService.IndexDocumentsAsync(documents.Skip(offset).Take(RebuildBatchSize));
}
_logger.LogInformation(
"用户收藏索引重建完成:收藏 {FavoriteCount} 条,写入索引 {IndexedCount} 条,商品缺失跳过 {MissingCount} 条。",
favorites.Count, documents.Count, missingGoodsCount);
return documents.Count;
}
/// <summary>
/// 收藏落库成功但索引写入失败时的补偿:撤销本次新增的收藏记录、还原被修改的收藏分组。
/// </summary>
private async Task CompensateWriteFailureAsync(List<long> insertedIds, List<(long Id, int PreviousGroupId)> changedGroupIds)
{
try
{
if (insertedIds.Count > 0)
{
await _favoriteRepository.Orm.Delete<UserGoodsFavoriteEntity>()
.Where(x => insertedIds.Contains(x.Id))
.ExecuteAffrowsAsync();
}
foreach (var (id, previousGroupId) in changedGroupIds)
{
await _favoriteRepository.Orm.Update<UserGoodsFavoriteEntity>()
.Set(x => x.GroupId, previousGroupId)
.Where(x => x.Id == id)
.ExecuteAffrowsAsync();
}
}
catch (Exception ex)
{
_logger.LogError(ex,
"回滚用户收藏记录失败。Inserted={InsertedCount} GroupChanged={GroupChangedCount}",
insertedIds.Count, changedGroupIds.Count);
}
}
/// <summary>
/// 取分组名:分组ID &lt;= 0 返回默认分组名,分组不存在返回空串。
/// </summary>
private async Task<string> ResolveGroupNameAsync(string userName, int groupId)
{
if (groupId <= 0)
{
return DefaultGroupName;
}
var group = await _groupRepository.Select
.Where(x => x.Id == groupId && x.UserName == userName)
.FirstAsync();
return group?.GroupName ?? string.Empty;
}
/// <summary>
/// 组装收藏索引文档:收藏记录 + 商品快照 + 分组名。
/// </summary>
private static UserFavoritesSearchDocument BuildDocument(UserGoodsFavoriteEntity favorite, GoodsEntity goods, string groupName)
{
return new UserFavoritesSearchDocument
{
Id = UserFavoritesSearchDocument.BuildId(favorite.UserName, favorite.GoodsId),
FavId = favorite.Id,
UserName = favorite.UserName,
GroupId = favorite.GroupId,
GroupName = groupName,
GoodsId = goods.GoodsId,
Platform = goods.Platform,
Title = goods.Title ?? string.Empty,
ThumbUrl = goods.ThumbUrl,
CatId1 = goods.CatId1,
CatId2 = goods.CatId2,
CatId3 = goods.CatId3,
CatId4 = goods.CatId4,
MinPrice = goods.MinPrice,
SoldQuantity = goods.SoldQuantity,
CreatedAt = favorite.CreatedAt,
};
}
private static UserFavoriteItem ToItem(UserFavoritesSearchDocument document)
{
return new UserFavoriteItem
{
Id = document.FavId,
UserName = document.UserName,
GroupId = document.GroupId,
GroupName = document.GroupName,
GoodsId = document.GoodsId,
Platform = document.Platform,
Title = document.Title,
ThumbUrl = document.ThumbUrl,
CatId1 = document.CatId1,
CatId2 = document.CatId2,
CatId3 = document.CatId3,
CatId4 = document.CatId4,
MinPrice = document.MinPrice,
SoldQuantity = document.SoldQuantity,
CreatedAt = document.CreatedAt,
};
}
/// <summary>
/// 解析排序方式,非法值一律按“收藏时间倒序”处理。
/// </summary>
private static UserFavoritesSortBy ParseSortBy(string? sortBy)
{
if (string.IsNullOrWhiteSpace(sortBy))
{
return UserFavoritesSortBy.CreatedTimeDesc;
}
return Enum.TryParse<UserFavoritesSortBy>(sortBy, ignoreCase: true, out var value)
? value
: UserFavoritesSortBy.CreatedTimeDesc;
}
}
}
File renamed without changes.
@@ -10,11 +10,17 @@
<ItemGroup> <ItemGroup>
<ProjectReference Include="..\..\Store.Framework\Store.Framework.csproj" /> <ProjectReference Include="..\..\Store.Framework\Store.Framework.csproj" />
</ItemGroup> </ItemGroup>
<ItemGroup> <!--<ItemGroup>
<!-- 本模块自己的配置文件:源码里叫 appsettings.json,构建后复制到宿主输出目录时改名为 --><!-- 本模块自己的配置文件:源码里叫 appsettings.json,构建后复制到宿主输出目录时改名为
appsettings.CloudProduct.json,避免和宿主自己的 appsettings.json 互相覆盖。 appsettings.CloudProduct.json,避免和宿主自己的 appsettings.json 互相覆盖。
由 builder.AddStoreHub() 自动并入宿主配置树(在 appsettings*.json 之后、环境变量之前)。 --> 由 builder.AddStoreHub() 自动并入宿主配置树(在 appsettings*.json 之后、环境变量之前)。 --><!--
<None Update="appsettings.json" Link="appsettings.CloudProduct.json" CopyToOutputDirectory="PreserveNewest" /> <None Update="appsettings.json" Link="appsettings.CloudProduct.json" CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>-->
<ItemGroup>
<None Update="appsettings.CloudProduct.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="Hangfire.AspNetCore" Version="1.8.25" /> <PackageReference Include="Hangfire.AspNetCore" Version="1.8.25" />
@@ -2,7 +2,8 @@
"CloudProductConnection": "Server=192.168.0.200;Port=3306;Database=goods_center;Uid=root;Pwd=123456;Allow User Variables=true", "CloudProductConnection": "Server=192.168.0.200;Port=3306;Database=goods_center;Uid=root;Pwd=123456;Allow User Variables=true",
"Search": { "Search": {
"Url": "http://192.168.0.200:9200", "Url": "http://192.168.0.200:9200",
"IndexName": "goods_search" "IndexName": "goods_search",
"FavoritesIndexName": "user_goods_favorites_search"
}, },
"RawData": { "RawData": {
"Path": "E:\\GoodsRawData" "Path": "E:\\GoodsRawData"
@@ -14,5 +15,11 @@
}, },
"Delete": { "Delete": {
"SoftDelete": true "SoftDelete": true
},
"Hangfire": {
"Dashboard" :{
"User": "admin",
"Pass": "1234560"
}
} }
} }
@@ -0,0 +1,107 @@
using Asp.Versioning;
using MAX.Framework.Dtos;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using MySqlX.XDevAPI.Common;
using Store.Framework.Base;
using Store.Framework.Models;
using Store.ImageCache.Dtos;
using Store.ImageCache.Services;
using System;
using System.Collections.Generic;
namespace KJD_Web.Controllers
{
[ApiVersionNeutral]
[Route("api/ImageCache/[action]")]
public class ImageCacheController : AppControllerBase
{
private readonly ImageCacheService _imageCacheService;
private readonly ILogger<ImageCacheController> _logger;
public ImageCacheController(ImageCacheService imageCacheService, ILogger<ImageCacheController> logger)
{
if (imageCacheService == null)
{
throw new ArgumentNullException("imageCacheService");
}
_imageCacheService = imageCacheService;
_logger = logger;
}
/// <summary>
/// 批量按 MD5 查询图片缓存。
/// </summary>
[HttpPost]
public ApiResult<List<ImageCacheDto>> GetImageCache(ImageCacheBatchQueryRequest request)
{
List<ImageCacheDto> data = new List<ImageCacheDto>();
try
{
if (request != null && request.Md5s != null)
{
data = _imageCacheService.GetByMd5s(request.Md5s, request.Platform);
}
return ApiResult.Ok(data);
}
catch (ArgumentException ex)
{
return ApiResult.Fail(ex.Message);
}
}
/// <summary>
/// 按 MD5 和平台更新平台图片 URL。
/// </summary>
[HttpPost]
public ApiResult<List<string>> AddOrUpdate(ImageCacheUpdateUrlRequest[] requests)
{
if (requests == null || requests.Length == 0)
{
return ApiResult.Fail("参数不能为空");
}
var failedItems = new List<string>();
foreach (var item in requests)
{
if (item == null)
{
return ApiResult.Fail("图片参数不能包含空项", ResultCode.ValidationError);
}
try
{
if (!_imageCacheService.AddOrUpdate(item.Md5, item.Platform, item.PlatformUrl))
{
failedItems.Add(item.Md5);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "AddOrUpdate 失败, Md5={Md5}", item.Md5);
failedItems.Add(item.Md5);
}
}
return failedItems.Count == 0
? ApiResult.Ok()
: ApiResult.Fail("部分图片失败", failedItems);
}
public class ImageCacheBatchQueryRequest
{
public List<string> Md5s { get; set; }
public byte? Platform { get; set; }
}
public class ImageCacheUpdateUrlRequest
{
public string Md5 { get; set; }
public byte Platform { get; set; }
public string PlatformUrl { get; set; }
}
}
}
@@ -0,0 +1,14 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.Json.Serialization;
namespace Store.ImageCache.Dtos
{
public class ImageCacheDto
{
public byte platform { get; set; }
public string md5 { get; set; }
public string platform_url { get; set; }
}
}
@@ -0,0 +1,32 @@
using FreeSql.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.Json.Serialization;
namespace Store.ImageCache.Entities
{
[Table(Name = "images_0")]
public class ImageCacheEntity
{
[JsonIgnore]
[Column(Name = "id", IsIdentity = true, IsPrimary = true)]
public long id { get; set; }
[Column(Name = "platform")]
public byte platform { get; set; }
//[JsonProperty("md5")]
[Column(Name = "source_url_md5", StringLength = 32)]
public string source_url_md5 { get; set; }
[Column(Name = "platform_url", StringLength = 1000)]
public string platform_url { get; set; }
[JsonIgnore]
[Column(Name = "create_time")]
public DateTime create_time { get; set; }
[JsonIgnore]
[Column(Name = "update_time")]
public DateTime update_time { get; set; }
}
}
@@ -0,0 +1,17 @@
using Riok.Mapperly.Abstractions;
using Store.Framework.Models;
using Store.ImageCache.Dtos;
using Store.ImageCache.Entities;
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.ImageCache.Mapper
{
[Mapper(RequiredMappingStrategy = RequiredMappingStrategy.Target)]
public partial class ImageCacheMapper
{
[MapProperty(nameof(ImageCacheEntity.source_url_md5), nameof(ImageCacheDto.md5))]
public partial ImageCacheDto ToDto(ImageCacheEntity entity);
}
}
+47
View File
@@ -0,0 +1,47 @@
using MAX.Core.Interfaces;
using MAX.Framework.Interfaces;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using MySql.Data.MySqlClient;
namespace Store.Modules.CloudProduct
{
public class Module : IModule
{
/// <summary>
/// 本模块自己的配置文件
/// </summary>
public const string ConfigurationFileName = "appsettings.ImageCache.json";
public int Priority => IntPriority.Normal;
/// <summary>
/// 服务注册阶段(builder.Build() 之前):这里只能拿到容器和配置,碰不到 app
/// </summary>
public void AddModule(IHostApplicationBuilder host)
{
IServiceCollection services = host.Services;
IConfigurationManager configuration = host.Configuration;
if (!string.IsNullOrWhiteSpace(ConfigurationFileName))
{
string path = Path.IsPathRooted(ConfigurationFileName)? ConfigurationFileName: Path.Combine(AppContext.BaseDirectory, ConfigurationFileName);
configuration.AddJsonFile(path, optional: false, reloadOnChange: true);
}
}
/// <summary>
/// 管道装配阶段(builder.Build() 之后、app.Run() 之前):这里可以挂中间件、解析容器里的服务
/// </summary>
public void UseModule(IApplicationBuilder app)
{
}
}
}
@@ -0,0 +1,172 @@
using MAX.Core.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Store.ImageCache.Dtos;
using Store.ImageCache.Entities;
using Store.ImageCache.Mapper;
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.ImageCache.Services
{
public class ImageCacheService : ISingletonDependency
{
private const int Md5Length = 32;
private const int PlatformUrlMaxLength = 1000;
private readonly IFreeSql _freeSql;
private ImageCacheMapper mapper;
public ImageCacheService([FromKeyedServices("ImageCacheConnection")] IFreeSql freeSql)
{
mapper = new ImageCacheMapper();
if (freeSql == null)
{
throw new ArgumentNullException("freeSql");
}
_freeSql = freeSql;
}
/// <summary>
/// 按 MD5 查询图片缓存;platform 为空时返回该 MD5 在所有平台的缓存。
/// </summary>
public ImageCacheDto GetByMd5(string sourceUrlMd5, byte? platform = null)
{
var md5 = NormalizeMd5(sourceUrlMd5);
return GetByMd5sInternal(new List<string> { md5 }, platform).FirstOrDefault();
}
/// <summary>
/// 批量按 MD5 查询图片缓存。MD5 会按首字符分组,只查询对应的 images_0 到 images_f 分表。
/// </summary>
public List<ImageCacheDto> GetByMd5s(IEnumerable<string> sourceUrlMd5s, byte? platform = null)
{
return GetByMd5sInternal(NormalizeMd5s(sourceUrlMd5s), platform);
}
/// <summary>
/// 按 MD5 和平台直接修改平台图片 URL,未找到时返回 false。
/// </summary>
public bool AddOrUpdate(string sourceUrlMd5, byte platform, string platformUrl)
{
var md5 = NormalizeMd5(sourceUrlMd5);
ValidatePlatformUrl(platformUrl);
var tableName = GetTableName(md5[0]);
var existing = _freeSql.Select<ImageCacheEntity>()
.AsTable((type, oldName) => tableName)
.Where(a => a.source_url_md5 == sourceUrlMd5 && a.platform == platform)
.First();
var now = DateTime.Now;
if (existing != null)
{
var affected = _freeSql.Update<ImageCacheEntity>()
.AsTable(tableName)
.Set(a => a.platform_url, platformUrl)
.Set(a => a.update_time, now)
.Where(a => a.source_url_md5 == md5 && a.platform == platform)
.ExecuteAffrows();
return affected > 0;
}
else
{
ImageCacheEntity imageCache = new ImageCacheEntity();
imageCache.id = 0;
imageCache.source_url_md5 = md5;
imageCache.platform = platform;
imageCache.platform_url = platformUrl;
imageCache.create_time = now;
imageCache.update_time = now;
imageCache.id = _freeSql.Insert(imageCache)
.AsTable(tableName)
.ExecuteIdentity();
return imageCache.id > 0;
}
}
private List<ImageCacheDto> GetByMd5sInternal(List<string> md5s, byte? platform)
{
var result = new List<ImageCacheDto>();
if (md5s.Count == 0)
{
return result;
}
foreach (var shard in md5s.GroupBy(a => a[0]))
{
var tableName = GetTableName(shard.Key);
var md5sInTable = shard.ToList();
var query = _freeSql.Select<ImageCacheEntity>()
.AsTable((type, oldName) => tableName)
.Where(a => md5sInTable.Contains(a.source_url_md5));
if (platform.HasValue)
{
var platformValue = platform.Value;
query = query.Where(a => a.platform == platformValue);
}
result.AddRange(query.ToList().Select(mapper.ToDto));
}
return result;
}
private List<string> NormalizeMd5s(IEnumerable<string> sourceUrlMd5s)
{
if (sourceUrlMd5s == null)
{
throw new ArgumentNullException("sourceUrlMd5s");
}
var result = new List<string>();
foreach (var sourceUrlMd5 in sourceUrlMd5s)
{
var md5 = NormalizeMd5(sourceUrlMd5);
if (!result.Contains(md5))
{
result.Add(md5);
}
}
return result;
}
private string NormalizeMd5(string sourceUrlMd5)
{
if (string.IsNullOrWhiteSpace(sourceUrlMd5))
{
throw new ArgumentException("MD5 不能为空", "sourceUrlMd5");
}
var md5 = sourceUrlMd5.Trim().ToLowerInvariant();
if (md5.Length != Md5Length || md5.Any(a => !Uri.IsHexDigit(a)))
{
throw new ArgumentException("MD5 必须是 32 位十六进制字符串", "sourceUrlMd5");
}
return md5;
}
private string GetTableName(char shard)
{
return "images_" + shard;
}
private void ValidatePlatformUrl(string platformUrl)
{
if (string.IsNullOrWhiteSpace(platformUrl))
{
throw new ArgumentException("平台图片 URL 不能为空", "platformUrl");
}
if (platformUrl.Length > PlatformUrlMaxLength)
{
throw new ArgumentException("平台图片 URL 长度不能超过 1000", "platformUrl");
}
}
}
}
+45
View File
@@ -0,0 +1,45 @@
using MAX.Core.DependencyInjection;
using MAX.Core.Interfaces;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System.ComponentModel;
namespace Store.Modules.CloudProduct
{
public class Startup : IStartup
{
public int Priority => IntPriority.Normal;
public void Initialize()
{
}
public void Register(IServiceRegistrar registrar)
{
Func<IServiceProvider, IFreeSql> KJDFsqlFactory = r =>
{
var config = r.GetRequiredService<IConfiguration>();
var connection = config.GetValue<string>("ImageCache:ConnectionString");
IFreeSql fsql = new FreeSql.FreeSqlBuilder()
.UseConnectionString(FreeSql.DataType.MySql, connection)
.UseAdoConnectionPool(true)
.Build();
return fsql;
};
registrar.RegisterSingleton<IFreeSql>("ImageCacheConnection", (s, k) =>
{
return KJDFsqlFactory(s);
});
}
public void Start(IServiceProvider serviceProvider)
{
}
}
}
@@ -0,0 +1,17 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
</PropertyGroup>
<ItemGroup>
<FrameworkReference Include="Microsoft.AspNetCore.App" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\Store.Framework\Store.Framework.csproj" />
</ItemGroup>
<ItemGroup>
<None Update="appsettings.ImageCache.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
</Project>
@@ -0,0 +1,5 @@
{
"ImageCache": {
"ConnectionString": "Server=192.168.0.200;Port=3306;Database=ImageCache;Uid=root;Pwd=123456;Allow User Variables=true"
}
}
@@ -0,0 +1,11 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Shops.Contracts
{
public interface IShopQueryService
{
DateTime GetExpireTime(string shopId);
}
}
@@ -0,0 +1,7 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
</PropertyGroup>
</Project>
+144
View File
@@ -0,0 +1,144 @@
using FreeSql.DataAnnotations;
using System;
namespace YourNamespace
{
/// <summary>
/// 店铺表
/// </summary>
[Table(Name = "wxxd.shop")]
public class ShopEntity
{
/// <summary>
/// 表id
/// </summary>
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
public int Id { get; set; }
/// <summary>
/// login_name
/// </summary>
[Column(Name = "login_name")]
public string LoginName { get; set; }
/// <summary>
/// login_pass
/// </summary>
[Column(Name = "login_pass")]
public string LoginPass { get; set; }
/// <summary>
/// cookie
/// </summary>
[Column(Name = "cookie")]
public string Cookie { get; set; }
/// <summary>
/// cookie2
/// </summary>
[Column(Name = "cookie2")]
public string Cookie2 { get; set; }
/// <summary>
/// anti_contents
/// </summary>
[Column(Name = "anti_contents")]
public string AntiContents { get; set; }
/// <summary>
/// openid
/// </summary>
[Column(Name = "openid")]
public string Openid { get; set; }
/// <summary>
/// shop_id
/// </summary>
[Column(Name = "shop_id")]
public string ShopId { get; set; }
/// <summary>
/// shop_account
/// </summary>
[Column(Name = "shop_account")]
public string ShopAccount { get; set; }
/// <summary>
/// sub_user_name
/// </summary>
[Column(Name = "sub_user_name")]
public string SubUserName { get; set; }
/// <summary>
/// user_name
/// </summary>
[Column(Name = "user_name")]
public string UserName { get; set; }
/// <summary>
/// 店铺分组名称(非子账号分组)
/// </summary>
[Column(Name = "group_name")]
public string GroupName { get; set; }
/// <summary>
/// add_time
/// </summary>
[Column(Name = "add_time")]
public DateTime? AddTime { get; set; }
/// <summary>
/// mdy_time
/// </summary>
[Column(Name = "mdy_time")]
public DateTime? MdyTime { get; set; }
/// <summary>
/// 店铺所属公司
/// </summary>
[Column(Name = "company_name")]
public string CompanyName { get; set; }
/// <summary>
/// 备注
/// </summary>
[Column(Name = "notes")]
public string Notes { get; set; }
/// <summary>
/// login_status
/// </summary>
[Column(Name = "login_status")]
public string LoginStatus { get; set; }
/// <summary>
/// 店铺每月商品上传限额剩余
/// </summary>
[Column(Name = "add_product_remaining")]
public int AddProductRemaining { get; set; }
/// <summary>
/// 上传限额所处月份
/// </summary>
[Column(Name = "add_product_month")]
public byte AddProductMonth { get; set; }
/// <summary>
/// 分配的二级超管的user_name
/// </summary>
[Column(Name = "operate_sub_sa_name")]
public string OperateSubSaName { get; set; }
/// <summary>
/// 分配二级超管的时间
/// </summary>
[Column(Name = "add_sub_sa_time")]
public DateTime? AddSubSaTime { get; set; }
/// <summary>
/// login_status2
/// </summary>
[Column(Name = "login_status2")]
public string LoginStatus2 { get; set; }
}
}
@@ -0,0 +1,43 @@
using FreeSql.DataAnnotations;
using System;
namespace Store.Users.Entities
{
/// <summary>
/// 商店过期
/// </summary>
[Table(Name = "wxxd.user_points_shop_expire")]
public class ShopExpireEntity
{
/// <summary>
/// ID
/// </summary>
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
public int Id { get; set; }
/// <summary>
/// 商店ID
/// </summary>
[Column(Name = "shop_id")]
public string ShopId { get; set; }
/// <summary>
/// 过期时间
/// </summary>
// 数据库列名末尾包含 U+200C,不能改成普通 expire_time。
[Column(Name = "expire_time")]
public int ExpireTime { get; set; }
/// <summary>
/// 添加时间
/// </summary>
[Column(Name = "add_time")]
public DateTime AddTime { get; set; }
/// <summary>
/// 修改时间
/// </summary>
[Column(Name = "mdy_time")]
public DateTime MdyTime { get; set; }
}
}
@@ -0,0 +1,47 @@
using FreeSql;
using MAX.Core.DependencyInjection;
using MAX.Core.Helpers;
using Store.Users.Entities;
using System;
using System.Collections.Generic;
using System.Text;
using YourNamespace;
namespace Store.Shops.Repositories
{
public interface IShopRepository : IBaseRepository<ShopEntity>
{
/// <summary>
/// 获取用户商铺过期时间
/// </summary>
/// <param name="ShopId"></param>
/// <returns></returns>
DateTime GetExpireTime(string ShopId);
}
internal class ShopRepository : BaseRepository<ShopEntity>, IShopRepository, ITransientDependency
{
private readonly IFreeSql _freeSql;
public ShopRepository(IFreeSql freeSql) : base(freeSql)
{
_freeSql = freeSql;
}
/// <summary>
/// 获取用户商铺过期时间
/// </summary>
/// <param name="ShopId"></param>
public DateTime GetExpireTime(string ShopId)
{
ShopExpireEntity currentExpire = _freeSql.Select<ShopExpireEntity>()
.Where(a => a.ShopId == ShopId)
.ForUpdate()
.First();
if (currentExpire == null)
{
return DateTime.MinValue;
}
return DateHelper.ConvertFromUnixTimestampInSeconds(currentExpire.ExpireTime);
}
}
}
@@ -0,0 +1,23 @@
using MAX.Core.DependencyInjection;
using Store.Shops.Contracts;
using Store.Shops.Repositories;
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Shops.Services
{
internal class ShopQueryService: IShopQueryService, ITransientDependency
{
private readonly IShopRepository _shopRepository;
public ShopQueryService(IShopRepository shopRepository)
{
_shopRepository = shopRepository;
}
public DateTime GetExpireTime(string shopId)
{
return _shopRepository.GetExpireTime(shopId);
}
}
}
+25
View File
@@ -0,0 +1,25 @@
using MAX.Core.DependencyInjection;
using MAX.Core.Interfaces;
namespace Store.Shops
{
public class Startup : IStartup
{
public int Priority => IntPriority.Normal;
public void Initialize()
{
}
public void Register(IServiceRegistrar registrar)
{
}
public void Start(IServiceProvider serviceProvider)
{
}
}
}
+10
View File
@@ -0,0 +1,10 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\..\Store.Framework\Store.Framework.csproj" />
<ProjectReference Include="..\Store.Shops.Contracts\Store.Shops.Contracts.csproj" />
</ItemGroup>
</Project>
@@ -0,0 +1,147 @@
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Text;
namespace Store.Users.Contracts.Dtos
{
public class UserInfo
{/// <summary>
/// ID
/// </summary>
public int Id { get; set; }
/// <summary>
/// 用户昵称
/// </summary>
public string NickName { get; set; }
/// <summary>
/// 用户名称(登录账户)
/// </summary>
public string UserName { get; set; }
/// <summary>
/// 登录密码
/// </summary>
public string Password { get; set; }
/// <summary>
/// card_id
/// </summary>
public string CardId { get; set; }
/// <summary>
/// 用户分组 3主号 4客服 5加盟 8登录 9采购 10加盟 11上货
/// </summary>
public byte GroupId { get; set; }
/// <summary>
/// 父账户用户名
/// </summary>
public string ParentUserName { get; set; }
/// <summary>
/// oem编号,仅oem用户有值
/// </summary>
public string OemId { get; set; }
/// <summary>
/// 手机号
/// </summary>
public string Mobile { get; set; }
/// <summary>
/// 添加时间
/// </summary>
public DateTime? AddTime { get; set; }
/// <summary>
/// 修改时间
/// </summary>
public DateTime? MdyTime { get; set; }
/// <summary>
/// 公司名称
/// </summary>
public string CompanyName { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Notes { get; set; }
/// <summary>
/// 超管等级 0 普通用户 1 超级管理员
/// </summary>
public short? SaLevel { get; set; }
/// <summary>
/// 账户权限
/// </summary>
public string Authority { get; set; }
/// <summary>
/// 子账号被禁止展示的功能页面
/// </summary>
public string ForbiddenPage { get; set; }
/// <summary>
/// 账户积分,1积分=1元
/// </summary>
public decimal Points { get; set; }
/// <summary>
/// 积分历史累计充值金额
/// </summary>
public decimal? RechargePointsTotal { get; set; }
/// <summary>
/// 店铺每续费一个月需要的积分,单位元
/// </summary>
public int ShopPointsPerMonth { get; set; }
/// <summary>
/// 可用余额
/// </summary>
public decimal? Balance { get; set; }
/// <summary>
/// 累计充值金额
/// </summary>
public decimal? RechargeAmountTotal { get; set; }
/// <summary>
/// 每单中转仓快递费用,单位元,两位小数
/// </summary>
public decimal? PostagePerOrder { get; set; }
/// <summary>
/// 每单中转仓退货快递费用,单位元,两位小数
/// </summary>
public decimal? RefundPostagePerOrder { get; set; }
/// <summary>
/// 礼物每单额外收取费用,单位元,两位小数
/// </summary>
public decimal? GiftOemAmountPerOrder { get; set; }
/// <summary>
/// 同步物流费用,单位元,两位小数
/// </summary>
public decimal? SyncLogisticsPerOrder { get; set; }
/// <summary>
/// 是否主账户
/// </summary>
public bool IsMainUser
{
get => string.IsNullOrWhiteSpace(ParentUserName);
}
/// <summary>
/// 是否OEM租户
/// </summary>
public bool IsOEMTenant => !string.IsNullOrWhiteSpace(OemId);
}
}
@@ -0,0 +1,30 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Store.Users.Contracts.Enums;
/// <summary>
/// 用户付款类型
/// </summary>
public enum UserPaymentTypes
{
充值 = 1,
//采购花费 = 2,
//产品退款到账 = 3,
//运费退款到账 = 4,
//采购收款 = 5,
//产品退款扣除 = 6,
//运费退款扣除 = 7,
礼物单支出 = 16,
中转仓扣费支出 = 20,
中转仓作废返还收入 = 23,
中转仓超重支出 = 24,
退货包裹扣费支出 = 26,
中转仓快递超重费用 = 28,
支付宝在线充值 = 30,
云仓退货支出 = 31,
礼物单退费 = 34,
同步单号 = 55,
}
@@ -0,0 +1,12 @@
using Store.Users.Contracts.Dtos;
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Users.Contracts
{
public interface IUserQueryService
{
Task<UserInfo> GetUser(string userName);
}
}
@@ -0,0 +1,6 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
</PropertyGroup>
</Project>
@@ -0,0 +1,81 @@
//using MediatR;
//using Store.Framework.Models;
//using Store.Shops.Contracts;
//using Store.Users.Contracts.Dtos;
//using Store.Users.Entities;
//using Store.Users.Repositories;
//using System;
//using System.Collections.Generic;
//using System.Text;
//namespace Store.Users.Commands
//{
// /// <summary>
// /// 商铺续费
// /// </summary>
// /// <param name="UserName"></param>
// /// <param name="ShopId"></param>
// /// <param name="RenewDuration"></param>
// internal record class ShopRenewCommand(string UserName, string ShopId, int RenewDuration) : IRequest<ShopRenewResponse>;
// internal class ShopRenewCommandHandler : IRequestHandler<ShopRenewCommand, ShopRenewResponse>
// {
// private readonly IUserRepository _userRepository;
// private readonly IShopQueryService _shopQueryService;
// public ShopRenewCommandHandler(IUserRepository userRepository, IShopQueryService shopQueryService)
// {
// _userRepository = userRepository;
// _shopQueryService = shopQueryService;
// }
// async Task<ShopRenewResponse> IRequestHandler<ShopRenewCommand, ShopRenewResponse>.Handle(ShopRenewCommand request, CancellationToken cancellationToken)
// {
// ShopRenewResponse response = new ShopRenewResponse();
// var user = await _userRepository.GetUser(request.UserName);
// int shopPointsPerMonth = Math.Max(30, user.ShopPointsPerMonth);
// int deltaPoints = shopPointsPerMonth * request.RenewDuration;
// int newPoints = (int)user.Points - deltaPoints;
// DateTime expireTime = _shopQueryService.GetExpireTime(request.ShopId);
// if (currentExpire != null && currentExpire.ExpireTime > 0)
// {
// DateTime currentExpireTime = TimeUtils.StampToDateTime(currentExpire.ExpireTime);
// if (currentExpireTime > expireBaseTime)
// {
// expireBaseTime = currentExpireTime;
// }
// }
// int newExpireTime = CalculateNewExpireTime(expireBaseTime, request.RenewDuration);
// response.ShopId = request.ShopId;
// response.UserPoints = newPoints;
// response.ExpireTime‌ = newExpireTime;
// return response;
// }
// private int CalculateNewExpireTime(DateTime expireBaseTime, int renewDuration)
// {
// DateTime newExpireDateTime;
// try
// {
// newExpireDateTime = expireBaseTime.AddMonths(renewDuration);
// }
// catch (ArgumentOutOfRangeException)
// {
// throw new InvalidOperationException("续费时长超出允许范围");
// }
// if (newExpireDateTime > TimeUtils.StampToDateTime(int.MaxValue))
// {
// throw new InvalidOperationException("续费时间超出系统支持范围");
// }
// return TimeUtils.DateTimeToTimestampSeconds(newExpireDateTime);
// }
// }
//}
@@ -0,0 +1,29 @@
using Asp.Versioning;
using Microsoft.AspNetCore.Mvc;
using Store.Users.Contracts;
using Store.Users.Contracts.Dtos;
using Store.Users.Services;
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Users.Controllers
{
[ApiController]
[ApiVersionNeutral]
[Route("user/[action]")]
public class UserController : ControllerBase
{
private readonly IUserQueryService _userQuery;
public UserController(IUserQueryService userQuery)
{
_userQuery = userQuery;
}
[HttpGet]
public async Task<UserInfo> GetUser(string userName)
{
return await _userQuery.GetUser(userName);
}
}
}
@@ -0,0 +1,27 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Users.Dtos
{
/// <summary>
/// 用户续费商铺
/// </summary>
public class ShopRenewRequest
{
/// <summary>
/// 店铺ID
/// </summary>
public string ShopId { get; set; }
/// <summary>
/// 续费时长数值,例如 3;范围 1-120 个月
/// </summary>
public int RenewDuration { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
}
}
@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Users.Contracts.Dtos
{
public class ShopRenewResponse
{
public string ShopId { get; set; }
public int ExpireTime‌ { get; set; }
public int UserPoints { get; set; }
}
}
+93
View File
@@ -0,0 +1,93 @@
using FreeSql.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace Store.Users.Entities;
/// <summary>
/// OEM贴牌表
/// </summary>
[Table(Name = "wxxd.oem")]
public class OEMEntity
{
/// <summary>
/// id
/// </summary>
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
public int Id { get; set; }
/// <summary>
/// oem_id
/// </summary>
[Column(Name = "oem_id")]
public string OemId { get; set; }
/// <summary>
/// 贴牌名称
/// </summary>
[Column(Name = "oem_name")]
public string OemName { get; set; }
/// <summary>
/// 贴牌管理人主账户
/// </summary>
[Column(Name = "oem_owner")]
public string OemOwner { get; set; }
/// <summary>
/// 图标
/// </summary>
[Column(Name = "oem_icon")]
public string OemIcon { get; set; }
/// <summary>
/// 题图
/// </summary>
[Column(Name = "oem_img")]
public string OemImg { get; set; }
/// <summary>
/// add_time
/// </summary>
[Column(Name = "add_time")]
public DateTime AddTime { get; set; }
/// <summary>
/// mdy_time
/// </summary>
[Column(Name = "mdy_time")]
public DateTime MdyTime { get; set; }
/// <summary>
/// is_del
/// </summary>
[Column(Name = "is_del")]
public byte IsDel { get; set; }
/// <summary>
/// 可提现余额,单位分
/// </summary>
[Column(Name = "available_balance")]
public long AvailableBalance { get; set; }
/// <summary>
/// 冻结余额,单位分
/// </summary>
[Column(Name = "frozen_balance")]
public long FrozenBalance { get; set; }
/// <summary>
/// 累计返利金额,单位分
/// </summary>
[Column(Name = "total_rebate_amount")]
public long TotalRebateAmount { get; set; }
/// <summary>
/// 累计提现金额,单位分
/// </summary>
[Column(Name = "total_withdraw_amount")]
public long TotalWithdrawAmount { get; set; }
}
+175
View File
@@ -0,0 +1,175 @@
using FreeSql.DataAnnotations;
using System;
namespace Store.Users.Entities
{
/// <summary>
/// 用户表
/// </summary>
[Table(Name = "wxxd.user")]
public class UserEntity
{
/// <summary>
/// ID
/// </summary>
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
public int Id { get; set; }
/// <summary>
/// 用户昵称
/// </summary>
[Column(Name = "nick_name")]
public string NickName { get; set; }
/// <summary>
/// 用户名称(登录账户)
/// </summary>
[Column(Name = "user_name")]
public string UserName { get; set; }
/// <summary>
/// 登录密码
/// </summary>
[Column(Name = "password")]
public string Password { get; set; }
/// <summary>
/// card_id
/// </summary>
[Column(Name = "card_id")]
public string CardId { get; set; }
/// <summary>
/// 用户分组 3主号 4客服 5加盟 8登录 9采购 10加盟 11上货
/// </summary>
[Column(Name = "group_id")]
public byte GroupId { get; set; }
/// <summary>
/// 父账户用户名
/// </summary>
[Column(Name = "parent_user_name")]
public string ParentUserName { get; set; }
/// <summary>
/// oem编号,仅oem用户有值
/// </summary>
[Column(Name = "oem_id")]
public string OemId { get; set; }
/// <summary>
/// 手机号
/// </summary>
[Column(Name = "mobile")]
public string Mobile { get; set; }
/// <summary>
/// 添加时间
/// </summary>
[Column(Name = "add_time")]
public DateTime? AddTime { get; set; }
/// <summary>
/// 修改时间
/// </summary>
[Column(Name = "mdy_time")]
public DateTime? MdyTime { get; set; }
/// <summary>
/// 公司名称
/// </summary>
[Column(Name = "company_name")]
public string CompanyName { get; set; }
/// <summary>
/// 备注
/// </summary>
[Column(Name = "notes")]
public string Notes { get; set; }
/// <summary>
/// 超管等级 0 普通用户 1 超级管理员
/// </summary>
[Column(Name = "sa_level")]
public short? SaLevel { get; set; }
/// <summary>
/// 账户权限
/// </summary>
[Column(Name = "authority")]
public string Authority { get; set; }
/// <summary>
/// 子账号被禁止展示的功能页面
/// </summary>
[Column(Name = "forbidden_page")]
public string ForbiddenPage { get; set; }
/// <summary>
/// 账户积分,1积分=1元
/// </summary>
[Column(Name = "points")]
public decimal Points { get; set; }
/// <summary>
/// 积分历史累计充值金额
/// </summary>
[Column(Name = "recharge_points_total")]
public decimal? RechargePointsTotal { get; set; }
/// <summary>
/// 店铺每续费一个月需要的积分,单位元
/// </summary>
[Column(Name = "shop_points_per_month")]
public int ShopPointsPerMonth { get; set; }
/// <summary>
/// 可用余额
/// </summary>
[Column(Name = "balance")]
public decimal? Balance { get; set; }
/// <summary>
/// 累计充值金额
/// </summary>
[Column(Name = "recharge_amount_total")]
public decimal? RechargeAmountTotal { get; set; }
/// <summary>
/// 每单中转仓快递费用,单位元,两位小数
/// </summary>
[Column(Name = "postage_per_order")]
public decimal? PostagePerOrder { get; set; }
/// <summary>
/// 每单中转仓退货快递费用,单位元,两位小数
/// </summary>
[Column(Name = "refund_postage_per_order")]
public decimal? RefundPostagePerOrder { get; set; }
/// <summary>
/// 礼物每单额外收取费用,单位元,两位小数
/// </summary>
[Column(Name = "gift_oem_amount_per_order")]
public decimal? GiftOemAmountPerOrder { get; set; }
/// <summary>
/// 同步物流费用,单位元,两位小数
/// </summary>
[Column(Name = "sync_logistics_per_order")]
public decimal? SyncLogisticsPerOrder { get; set; }
/// <summary>
/// 是否主账户
/// </summary>
public bool IsMainUser
{
get => string.IsNullOrWhiteSpace(ParentUserName);
}
/// <summary>
/// 是否OEM租户
/// </summary>
public bool IsOEMTenant => !string.IsNullOrWhiteSpace(OemId);
}
}
@@ -0,0 +1,125 @@
using FreeSql.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace Store.Users.Entities;
[Table(Name = "wxxd.user_payment_record")]
public class UserPaymentRecordEntity
{
/// <summary>
/// id
/// </summary>
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
public long Id { get; set; }
/// <summary>
/// 变动类型,1:充值,2:采购花费,3:产品退款到账,4:运费退款到账,5:采购收款,6:产品退款扣除,7:运费退款扣除, 16:礼物单话费,20:中转仓扣费支出,23:中转仓退款收入
/// </summary>
[Column(Name = "type")]
public int Type { get; set; }
/// <summary>
/// 金额(元)
/// </summary>
[Column(Name = "amount")]
public decimal? Amount { get; set; }
/// <summary>
/// 归属oem用户的金额
/// </summary>
[Column(Name = "oem_amount")]
public decimal? OemAmount { get; set; }
/// <summary>
/// 余额(元)
/// </summary>
[Column(Name = "balance")]
public decimal? Balance { get; set; }
/// <summary>
/// 账户名
/// </summary>
[Column(Name = "user_name")]
public string UserName { get; set; }
/// <summary>
/// 平台编码
/// </summary>
[Column(Name = "platform_code")]
public string PlatformCode { get; set; }
/// <summary>
/// 订单id
/// </summary>
[Column(Name = "order_id")]
public string OrderId { get; set; }
/// <summary>
/// 售后单id
/// </summary>
[Column(Name = "after_sale_id")]
public long? AfterSaleId { get; set; }
/// <summary>
/// 创建人
/// </summary>
[Column(Name = "create_by")]
public string CreateBy { get; set; }
/// <summary>
/// 创建时间
/// </summary>
[Column(Name = "create_time")]
public DateTime CreateTime { get; set; }
/// <summary>
/// 修改人
/// </summary>
[Column(Name = "update_by")]
public string UpdateBy { get; set; }
/// <summary>
/// 修改时间
/// </summary>
[Column(Name = "update_time")]
public DateTime? UpdateTime { get; set; }
/// <summary>
/// 是否已删除
/// </summary>
[Column(Name = "is_deleted")]
public int IsDeleted { get; set; }
/// <summary>
/// 备注
/// </summary>
[Column(Name = "remark")]
public string Remark { get; set; }
/// <summary>
/// 扣款的对方账户名称
/// </summary>
[Column(Name = "counterparty_account_name")]
public string CounterpartyAccountName { get; set; }
/// <summary>
/// OEM是否结算 0未结算 1已结算
/// </summary>
[Column(Name = "settlement")]
public byte Settlement { get; set; } = 0;
/// <summary>
/// 退款流水号 外采&订单号
/// </summary>
[Column(Name = "refund_flow_no")]
public string RefundFlowNo { get; set; }
/// <summary>
/// 结算时间
/// </summary>
[Column(Name = "settlement_time")]
public DateTime? SettlementTime { get; set; }
}
@@ -0,0 +1,109 @@
using FreeSql.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace Store.Users.Entities
{
[Table(Name = "wxxd.user_points_record")]
public class UserPointsRecordEntity
{
/// <summary>
/// 主键(自增)
/// </summary>
[Column(Name = "id", IsPrimary = true, IsIdentity = true)]
public long Id { get; set; }
/// <summary>
/// 用户名(NOT NULL)
/// </summary>
[Column(Name = "user_name")]
public string UserName { get; set; }
/// <summary>
/// 用户昵称(NOT NULL)
/// </summary>
[Column(Name = "user_nick")]
public string UserNick { get; set; }
/// <summary>
/// 操作记录金额,单位元,最小1元(NOT NULL)
/// </summary>
[Column(Name = "delta_points")]
public decimal DeltaPoints { get; set; }
/// <summary>
/// 充值或消费后的当前金额(允许 NULL)
/// </summary>
[Column(Name = "new_points")]
public decimal? NewPoints { get; set; }
/// <summary>
/// 操作类型 消费 充值 转入 转出(NOT NULL)
/// </summary>
[Column(Name = "option_type")]
public string OptionType { get; set; }
/// <summary>
/// 操作者类型 管理员 用户(NOT NULL)
/// </summary>
[Column(Name = "operator_type")]
public string OperatorType { get; set; }
/// <summary>
/// 实际操作者用户名(NOT NULL)
/// </summary>
[Column(Name = "operator_name")]
public string OperatorName { get; set; }
/// <summary>
/// 消费店铺编号(消费才有值,充值为空,允许 NULL)
/// </summary>
[Column(Name = "shop_id")]
public string? ShopId { get; set; }
/// <summary>
/// 消费店铺名称(消费才有值,充值为空,允许 NULL)
/// </summary>
[Column(Name = "shop_account")]
public string? ShopAccount { get; set; }
/// <summary>
/// 备注(允许 NULL)
/// </summary>
[Column(Name = "remark")]
public string? Remark { get; set; }
/// <summary>
/// (点数转出时的)对方账户(允许 NULL)
/// </summary>
[Column(Name = "counterparty_account_name")]
public string? CounterpartyAccountName { get; set; }
/// <summary>
/// 支付宝订单的外部订单号(允许 NULL)
/// </summary>
[Column(Name = "out_trade_no")]
public string? OutTradeNo { get; set; }
/// <summary>
/// 添加时间(NOT NULL,默认 CURRENT_TIMESTAMP)
/// </summary>
[Column(Name = "add_time")]
public DateTime AddTime { get; set; }
/// <summary>
/// OEM是否结算 0未结算 1已结算
/// </summary>
[Column(Name = "settlement")]
public bool Settlement { get; set; }
/// <summary>
/// 结算时间
/// </summary>
[Column(Name = "settlement_time")]
public DateTime? SettlementTime { get; set; }
}
}
+15
View File
@@ -0,0 +1,15 @@
using Riok.Mapperly.Abstractions;
using Store.Users.Contracts.Dtos;
using Store.Users.Entities;
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Users.Mappers
{
[Mapper]
internal partial class UserMapper
{
public partial UserInfo ToInfo(UserEntity entity);
}
}
@@ -0,0 +1,50 @@
using FreeSql;
using MAX.Core.DependencyInjection;
using Store.Users.Contracts.Dtos;
using Store.Users.Entities;
using Store.Users.Mappers;
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Users.Repositories
{
public interface IUserRepository : IBaseRepository<UserEntity>
{
Task<UserEntity> GetUser(string userName);
}
internal class UserRepository : BaseRepository<UserEntity>, IUserRepository, ITransientDependency
{
private readonly IFreeSql _freeSql;
public UserRepository(IFreeSql freeSql) : base(freeSql)
{
_freeSql = freeSql;
}
public async Task<UserEntity> GetUser(string userName)
{
var sql = Where(a => a.UserName == userName).ToSql();
var user = await Where(a => a.UserName == userName).FirstAsync();
if (user != null)
{
if (user.IsMainUser == false)
{
var mainUser = await Where(a => a.UserName == user.ParentUserName).FirstAsync();
if (mainUser != null)
{
user.OemId = mainUser.OemId;
user.PostagePerOrder = mainUser.PostagePerOrder;
user.RefundPostagePerOrder = mainUser.RefundPostagePerOrder;
user.GiftOemAmountPerOrder = mainUser.GiftOemAmountPerOrder;
user.SyncLogisticsPerOrder = mainUser.SyncLogisticsPerOrder;
}
}
}
return user;
}
}
}
@@ -0,0 +1,43 @@
using MAX.Core.DependencyInjection;
using Store.Users.Contracts;
using Store.Users.Contracts.Dtos;
using Store.Users.Entities;
using Store.Users.Mappers;
using Store.Users.Repositories;
using System;
using System.Collections.Generic;
using System.Text;
namespace Store.Users.Services
{
internal class UserQueryService : IUserQueryService, ITransientDependency
{
private readonly IUserRepository _userRepository;
public UserQueryService(IUserRepository userRepository)
{
_userRepository = userRepository;
}
public async Task<UserInfo> GetUser(string userName)
{
var sql = _userRepository.Where(a => a.UserName == userName).ToSql();
var user = await _userRepository.Where(a => a.UserName == userName).FirstAsync();
if (user != null)
{
if (user.IsMainUser == false)
{
var mainUser = await _userRepository.Where(a => a.UserName == user.ParentUserName).FirstAsync();
if (mainUser != null)
{
user.OemId = mainUser.OemId;
user.PostagePerOrder = mainUser.PostagePerOrder;
user.RefundPostagePerOrder = mainUser.RefundPostagePerOrder;
user.GiftOemAmountPerOrder = mainUser.GiftOemAmountPerOrder;
user.SyncLogisticsPerOrder = mainUser.SyncLogisticsPerOrder;
}
}
}
return new UserMapper().ToInfo(user);
}
}
}
+22
View File
@@ -0,0 +1,22 @@
using MAX.Core.DependencyInjection;
using MAX.Core.Interfaces;
namespace Store.Users
{
public class Startup : IStartup
{
public int Priority => IntPriority.Normal;
public void Initialize()
{
}
public void Register(IServiceRegistrar registrar)
{
}
public void Start(IServiceProvider serviceProvider)
{
}
}
}
+13
View File
@@ -0,0 +1,13 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\..\Store.Framework\Store.Framework.csproj" />
<ProjectReference Include="..\Store.Shops.Contracts\Store.Shops.Contracts.csproj" />
<ProjectReference Include="..\Store.Users.Contracts\Store.Users.Contracts.csproj" />
</ItemGroup>
</Project>
+10 -6
View File
@@ -16,13 +16,15 @@ namespace Store.Api.Controllers
private readonly ITokenService _tokenService; private readonly ITokenService _tokenService;
private readonly ICurrentUser _currentUser; private readonly ICurrentUser _currentUser;
private readonly IOnlineUserStore _onlineUserStore; private readonly IOnlineUserStore _onlineUserStore;
private readonly ILogger<AuthController> _logger;
public AuthController( ITokenService tokenService, ICurrentUser currentUser, IOnlineUserStore onlineUserStore) public AuthController(ITokenService tokenService, ICurrentUser currentUser, IOnlineUserStore onlineUserStore, ILogger<AuthController> logger)
{ {
//_userService = userService; //_userService = userService;
_tokenService = tokenService; _tokenService = tokenService;
_currentUser = currentUser; _currentUser = currentUser;
_onlineUserStore = onlineUserStore; _onlineUserStore = onlineUserStore;
_logger = logger;
} }
/// <summary> /// <summary>
@@ -30,8 +32,10 @@ namespace Store.Api.Controllers
/// </summary> /// </summary>
[HttpPost] [HttpPost]
[AllowAnonymous] [AllowAnonymous]
public async Task<ApiResult<object?>> Login([FromBody] LoginRequest request) public async Task<ApiResult> Login([FromBody] LoginRequest request)
{ {
_logger.LogError("login errr");
_logger.LogInformation("login");
if (request is null || string.IsNullOrWhiteSpace(request.UserName) || string.IsNullOrWhiteSpace(request.Password)) if (request is null || string.IsNullOrWhiteSpace(request.UserName) || string.IsNullOrWhiteSpace(request.Password))
{ {
return ApiResult.Fail("用户名或密码不能为空", 400); return ApiResult.Fail("用户名或密码不能为空", 400);
@@ -50,7 +54,7 @@ namespace Store.Api.Controllers
//}; //};
//TokenResult token = _tokenService.CreateToken(claims); //TokenResult token = _tokenService.CreateToken(claims);
return ApiResult<object?>.Success(111); return ApiResult.Ok();
} }
/// <summary> /// <summary>
@@ -65,7 +69,7 @@ namespace Store.Api.Controllers
_onlineUserStore.SignOut(username); _onlineUserStore.SignOut(username);
} }
return ApiResult<object?>.Success(null); return ApiResult<object?>.Ok(null);
} }
/// <summary> /// <summary>
@@ -75,7 +79,7 @@ namespace Store.Api.Controllers
[Authorize] [Authorize]
public ApiResult<object?> Me() public ApiResult<object?> Me()
{ {
return ApiResult<object?>.Success(new return ApiResult<object?>.Ok(new
{ {
UserName = _currentUser.UserName, UserName = _currentUser.UserName,
NickName = _currentUser.NickName, NickName = _currentUser.NickName,
@@ -90,7 +94,7 @@ namespace Store.Api.Controllers
public ApiResult<object?> OnlineUsers() public ApiResult<object?> OnlineUsers()
{ {
IReadOnlyList<OnlineUserInfo> users = _onlineUserStore.GetOnlineUsers(); IReadOnlyList<OnlineUserInfo> users = _onlineUserStore.GetOnlineUsers();
return ApiResult<object?>.Success(new return ApiResult<object?>.Ok(new
{ {
Count = users.Count, Count = users.Count,
Users = users, Users = users,
+16 -16
View File
@@ -7,21 +7,21 @@ using System.Text.Json.Serialization;
namespace Store.Api.Controllers namespace Store.Api.Controllers
{ {
[ApiController] //[ApiController]
[ApiVersionNeutral] //[ApiVersionNeutral]
[Route("wxxd_user/[action]")] //[Route("wxxd_user/[action]")]
public class UserController : ControllerBase //public class UserController : ControllerBase
{ //{
private readonly IUserRepository _userRepository; // private readonly IUserRepository _userRepository;
public UserController(IUserRepository userRepository) // public UserController(IUserRepository userRepository)
{ // {
_userRepository = userRepository; // _userRepository = userRepository;
} // }
[HttpGet] // [HttpGet]
public string GetUser() // public string GetUser()
{ // {
return JsonSerializer.Serialize(_userRepository.Select.First()); // return JsonSerializer.Serialize(_userRepository.Select.First());
} // }
} //}
} }
@@ -1,34 +0,0 @@
using Asp.Versioning;
using MAX.Framework.Dtos;
using Microsoft.AspNetCore.Mvc;
using Store.Api;
using System.ComponentModel;
namespace Store.Api.Controllers
{
[ApiController]
[Description("测试温度")]
[ApiVersion("1.0")]
[Route("api/v{version:apiVersion}/[controller]")]
public class WeatherForecastController : ControllerBase
{
private static readonly string[] Summaries =
[
"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
];
[HttpGet(Name = "GetWeatherForecast")]
public IEnumerable<WeatherForecast> Get()
{
IEnumerable<WeatherForecast> data = Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
TemperatureC = Random.Shared.Next(-20, 55),
Summary = Summaries[Random.Shared.Next(Summaries.Length)]
})
.ToArray();
return data;
}
}
}
@@ -5,29 +5,29 @@ using Store.Api;
namespace Store.Api.Controllers.v2 namespace Store.Api.Controllers.v2
{ {
[ApiController] //[ApiController]
[ApiVersion("2.0")] //[ApiVersion("2.0")]
[Route("api/v{version:apiVersion}/[controller]")] //[Route("api/v{version:apiVersion}/[controller]")]
public class WeatherForecastController : ControllerBase //public class WeatherForecastController : ControllerBase
{ //{
private static readonly string[] Summaries = // private static readonly string[] Summaries =
[ // [
"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" // "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
]; // ];
[HttpGet(Name = "GetWeatherForecastV2")] // [HttpGet(Name = "GetWeatherForecastV2")]
public ApiResult<IEnumerable<WeatherForecastV2>> Get() // public ApiResult<IEnumerable<WeatherForecastV2>> Get()
{ // {
IEnumerable<WeatherForecastV2> data = Enumerable.Range(1, 10).Select(index => new WeatherForecastV2 // IEnumerable<WeatherForecastV2> data = Enumerable.Range(1, 10).Select(index => new WeatherForecastV2
{ // {
Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)), // Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
TemperatureC = Random.Shared.Next(-20, 55), // TemperatureC = Random.Shared.Next(-20, 55),
FeelsLikeC = Random.Shared.Next(-20, 55), // FeelsLikeC = Random.Shared.Next(-20, 55),
Summary = Summaries[Random.Shared.Next(Summaries.Length)] // Summary = Summaries[Random.Shared.Next(Summaries.Length)]
}) // })
.ToArray(); // .ToArray();
return ApiResult<IEnumerable<WeatherForecastV2>>.Success(data); // return ApiResult<IEnumerable<WeatherForecastV2>>.Success(data);
} // }
} //}
} }
+1
View File
@@ -36,6 +36,7 @@ public partial class Program
WebApplication app = builder.Build(); WebApplication app = builder.Build();
app.UseStore(); app.UseStore();
// 初始化 KJD 迁移的静态提供者(MysqlUtils 连接提供 / 业务配置读取) // 初始化 KJD 迁移的静态提供者(MysqlUtils 连接提供 / 业务配置读取)
//StoreHub.KJDWebService.Commons.AdoProvider.SetServiceProvider(app.Services); //StoreHub.KJDWebService.Commons.AdoProvider.SetServiceProvider(app.Services);
+2 -2
View File
@@ -6,7 +6,7 @@
"dotnetRunMessages": true, "dotnetRunMessages": true,
"launchBrowser": true, "launchBrowser": true,
"launchUrl": "scalar/v1", "launchUrl": "scalar/v1",
"applicationUrl": "http://localhost:9000", "applicationUrl": "http://localhost:14312",
"environmentVariables": { "environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development" "ASPNETCORE_ENVIRONMENT": "Development"
} }
@@ -16,7 +16,7 @@
"dotnetRunMessages": true, "dotnetRunMessages": true,
"launchBrowser": true, "launchBrowser": true,
"launchUrl": "scalar/v1", "launchUrl": "scalar/v1",
"applicationUrl": "https://localhost:7241;http://localhost:9000", "applicationUrl": "https://localhost:7241;http://localhost:14312",
"environmentVariables": { "environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development" "ASPNETCORE_ENVIRONMENT": "Development"
} }
+8 -5
View File
@@ -3,15 +3,16 @@
<PropertyGroup> <PropertyGroup>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings> <ImplicitUsings>enable</ImplicitUsings>
<SatelliteResourceLanguages>zh-Hans;zh-Hant;zh;en</SatelliteResourceLanguages>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
<Compile Remove="Log\**" /> <None Remove="Logs\**" />
<Content Remove="Log\**" />
<EmbeddedResource Remove="Log\**" />
<None Remove="Log\**" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.10" /> <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.10" />
@@ -19,7 +20,9 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ProjectReference Include="..\Models\CloudProduct\Store.Modules.CloudProduct.csproj" /> <ProjectReference Include="..\Modules\CloudProduct\Store.CloudProduct.csproj" />
<ProjectReference Include="..\Modules\Store.ImageCache\Store.ImageCache.csproj" />
<ProjectReference Include="..\Modules\Store.Users\Store.Users.csproj" />
<ProjectReference Include="..\Store.Framework\Store.Framework.csproj" /> <ProjectReference Include="..\Store.Framework\Store.Framework.csproj" />
</ItemGroup> </ItemGroup>
-13
View File
@@ -1,13 +0,0 @@
namespace Store.Api
{
public class WeatherForecast
{
public DateOnly Date { get; set; }
public int TemperatureC { get; set; }
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
public string? Summary { get; set; }
}
}
-15
View File
@@ -1,15 +0,0 @@
namespace Store.Api
{
public class WeatherForecastV2
{
public DateOnly Date { get; set; }
public int TemperatureC { get; set; }
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
public int FeelsLikeC { get; set; }
public string? Summary { get; set; }
}
}
+13
View File
@@ -0,0 +1,13 @@
{
"version": 1,
"isRoot": true,
"tools": {
"dotnet-ef": {
"version": "10.0.14",
"commands": [
"dotnet-ef"
],
"rollForward": false
}
}
}
+7 -2
View File
@@ -4,13 +4,18 @@
<Project Path="Core/MAX.Framework/MAX.Framework.csproj" /> <Project Path="Core/MAX.Framework/MAX.Framework.csproj" />
</Folder> </Folder>
<Folder Name="/Modules/"> <Folder Name="/Modules/">
<Project Path="Models/CloudProduct/Store.Modules.CloudProduct.csproj" Id="9720597a-661b-47d8-90c7-83e17c6d5920" /> <Project Path="Modules/CloudProduct/Store.CloudProduct.csproj" />
<Project Path="Modules/Store.ImageCache/Store.ImageCache.csproj" Id="53cc9cf1-62f9-4980-bad9-958bb3314370" />
<Project Path="Modules/Store.Shops.Contracts/Store.Shops.Contracts.csproj" Id="7d313823-f86a-450a-be29-8f915fc4b5b3" />
<Project Path="Modules/Store.Shops/Store.Shops.csproj" Id="b1c06d62-9cfb-4e87-b495-7077dd0c088d" />
<Project Path="Modules/Store.Users.Contracts/Store.Users.Contracts.csproj" Id="d4a8177b-503c-4205-96ce-da0e01c855db" />
<Project Path="Modules/Store.Users/Store.Users.csproj" />
</Folder> </Folder>
<Folder Name="/_SolutionItems/"> <Folder Name="/_SolutionItems/">
<File Path="Directory.Build.props" /> <File Path="Directory.Build.props" />
</Folder> </Folder>
<Project Path="Store.API/Store.Api.csproj" /> <Project Path="Store.API/Store.Api.csproj" />
<Project Path="Store.Framework/Store.Framework.csproj" /> <Project Path="Store.Framework/Store.Framework.csproj" />
<Project Path="StoreHub.KJDWebService/StoreHub.KJDWebService.csproj" /> <Project Path="Store.KJDWebService/StoreHub.KJDWebService.csproj" />
<Project Path="StoreHub.Services/Store.Services.csproj" /> <Project Path="StoreHub.Services/Store.Services.csproj" />
</Solution> </Solution>
+1 -4
View File
@@ -7,12 +7,9 @@ using System.Collections.Generic;
using System.Text; using System.Text;
namespace Store.Framework.Repositorys namespace Store.Framework.Repositorys
{
public interface IUserRepository : IBaseRepository<User>
{ {
} public class SqlRepository : WxRepository<User>, IScopedDependency
public class SqlRepository : WxRepository<User>, IUserRepository, IScopedDependency
{ {
public SqlRepository([FromKeyedServices("KJDDB")] IFreeSql fsql) : base(fsql) public SqlRepository([FromKeyedServices("KJDDB")] IFreeSql fsql) : base(fsql)
{ {
@@ -0,0 +1,8 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../Modules/CloudProduct/Store.CloudProduct.csproj" />
</ItemGroup>
</Project>
Loaded 100 of 102 files, more files were not shown because too many files have changed in this diff. Show more