802 lines
30 KiB
C#
802 lines
30 KiB
C#
using System.Globalization;
|
|
using System.Text.Json;
|
|
using MiaoJiZhang.Domain.Entities;
|
|
using MiaoJiZhang.Domain.Enums;
|
|
using MiaoJiZhang.Infrastructure.Persistence;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace MiaoJiZhang.Api.Services;
|
|
|
|
public record AgentTurnResult(
|
|
string Reply,
|
|
IReadOnlyList<Transaction> Transactions);
|
|
|
|
public class AgentService(
|
|
AppDbContext db,
|
|
ILlmClient llm,
|
|
BudgetPushService budgetPush,
|
|
ILogger<AgentService> logger)
|
|
{
|
|
private static readonly JsonSerializerOptions JsonOptions =
|
|
new(JsonSerializerDefaults.Web);
|
|
|
|
private static readonly object TransactionItemsSchema = Schema(
|
|
"""
|
|
{
|
|
"type": "object",
|
|
"properties": {
|
|
"items": {
|
|
"type": "array",
|
|
"minItems": 1,
|
|
"maxItems": 10,
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"type": {
|
|
"type": "string",
|
|
"enum": ["expense", "income", "transfer"],
|
|
"description": "账单类型；明确转账时使用 transfer"
|
|
},
|
|
"amount": {
|
|
"type": "number",
|
|
"exclusiveMinimum": 0
|
|
},
|
|
"categoryName": {
|
|
"type": "string",
|
|
"description": "支出分类：餐饮、饮品、购物、交通、住房、娱乐、医疗、学习、服饰、人情、旅行、其他；收入分类：工资、奖金、理财、兼职、红包、报销、其他"
|
|
},
|
|
"note": {
|
|
"type": "string",
|
|
"description": "适合明细列表展示的简短备注，不要照抄用户整句话"
|
|
},
|
|
"paymentMethod": {
|
|
"type": "string",
|
|
"description": "可选，例如微信支付、支付宝、现金"
|
|
},
|
|
"transferDirection": {
|
|
"type": "string",
|
|
"enum": ["in", "out"],
|
|
"description": "type=transfer 时必填，转入为 in，转出为 out"
|
|
},
|
|
"counterparty": {
|
|
"type": "string",
|
|
"description": "转账对方，可选"
|
|
},
|
|
"occurredAt": {
|
|
"type": "string",
|
|
"description": "可选，ISO 8601 时间；未提时间不要填写"
|
|
}
|
|
},
|
|
"required": ["type", "amount", "categoryName", "note"],
|
|
"additionalProperties": false
|
|
}
|
|
}
|
|
},
|
|
"required": ["items"],
|
|
"additionalProperties": false
|
|
}
|
|
""");
|
|
|
|
private static readonly IReadOnlyList<AgentToolDefinition> ChatTools =
|
|
[
|
|
new(
|
|
"create_transactions",
|
|
"仅当每笔交易的金额和收入/支出方向都明确时，创建一笔或多笔账单。裸金额、方向冲突或不确定时不得调用，应先询问用户。",
|
|
TransactionItemsSchema),
|
|
new(
|
|
"get_financial_summary",
|
|
"读取用户默认账本在指定周期内的真实收入、支出、结余和分类汇总。",
|
|
Schema(
|
|
"""
|
|
{
|
|
"type": "object",
|
|
"properties": {
|
|
"period": {
|
|
"type": "string",
|
|
"enum": ["today", "yesterday", "this_week", "this_month", "last_month", "this_year"]
|
|
}
|
|
},
|
|
"required": ["period"],
|
|
"additionalProperties": false
|
|
}
|
|
""")),
|
|
new(
|
|
"list_transactions",
|
|
"读取用户默认账本的近期真实账单，可按周期、收支方向和分类筛选。",
|
|
Schema(
|
|
"""
|
|
{
|
|
"type": "object",
|
|
"properties": {
|
|
"period": {
|
|
"type": "string",
|
|
"enum": ["today", "yesterday", "this_week", "this_month", "last_month", "this_year"]
|
|
},
|
|
"type": {
|
|
"type": "string",
|
|
"enum": ["expense", "income", "transfer"]
|
|
},
|
|
"categoryName": {
|
|
"type": "string"
|
|
},
|
|
"limit": {
|
|
"type": "integer",
|
|
"minimum": 1,
|
|
"maximum": 10
|
|
}
|
|
},
|
|
"required": ["period"],
|
|
"additionalProperties": false
|
|
}
|
|
""")),
|
|
new(
|
|
"get_budget_status",
|
|
"读取用户默认账本某月的总预算、分类预算、已花金额和周期预算状态。",
|
|
Schema(
|
|
"""
|
|
{
|
|
"type": "object",
|
|
"properties": {
|
|
"year": {
|
|
"type": "integer",
|
|
"minimum": 2000,
|
|
"maximum": 2200
|
|
},
|
|
"month": {
|
|
"type": "integer",
|
|
"minimum": 1,
|
|
"maximum": 12
|
|
}
|
|
},
|
|
"required": ["year", "month"],
|
|
"additionalProperties": false
|
|
}
|
|
""")),
|
|
];
|
|
|
|
private static readonly IReadOnlyList<AgentToolDefinition> DraftTools =
|
|
[
|
|
new(
|
|
"prepare_transactions",
|
|
"解析明确的自然语言交易草稿。金额或收支方向不明确时不要调用。",
|
|
TransactionItemsSchema),
|
|
];
|
|
|
|
public async Task<AgentTurnResult> RunAsync(
|
|
long userId,
|
|
long ledgerId,
|
|
bool allowWrites,
|
|
string userText,
|
|
ChatMessage sourceMessage,
|
|
string personaPrompt,
|
|
string conversationContext,
|
|
Func<string, CancellationToken, Task>? onToken = null,
|
|
Func<string, CancellationToken, Task>? onToolRunning = null,
|
|
CancellationToken ct = default)
|
|
{
|
|
if (!llm.IsEnabled)
|
|
throw new InvalidOperationException("AI 功能尚未配置");
|
|
if (sourceMessage.Id == 0)
|
|
await db.SaveChangesAsync(ct);
|
|
|
|
var created = new List<Transaction>();
|
|
var writeExecuted = false;
|
|
var response = await llm.RunAgentAsync(
|
|
BuildSystemPrompt(personaPrompt, conversationContext),
|
|
userText,
|
|
ChatTools,
|
|
async (call, toolCt) =>
|
|
{
|
|
logger.LogInformation(
|
|
"Executing AI agent tool. user={UserId} tool={Tool} callId={CallId}",
|
|
userId,
|
|
call.Name,
|
|
call.CallId);
|
|
return call.Name switch
|
|
{
|
|
"create_transactions" when allowWrites => await CreateTransactionsAsync(
|
|
userId,
|
|
ledgerId,
|
|
userText,
|
|
sourceMessage,
|
|
call.Arguments,
|
|
created,
|
|
() => writeExecuted,
|
|
() => writeExecuted = true,
|
|
toolCt),
|
|
"create_transactions" => Serialize(new
|
|
{
|
|
ok = false,
|
|
error = "AI 自动入账已关闭，请在记一笔页面手动确认",
|
|
}),
|
|
"get_financial_summary" => await FinancialSummaryAsync(
|
|
userId,
|
|
ledgerId,
|
|
call.Arguments,
|
|
toolCt),
|
|
"list_transactions" => await ListTransactionsAsync(
|
|
userId,
|
|
ledgerId,
|
|
call.Arguments,
|
|
toolCt),
|
|
"get_budget_status" => await BudgetStatusAsync(
|
|
userId,
|
|
ledgerId,
|
|
call.Arguments,
|
|
toolCt),
|
|
_ => Serialize(new { ok = false, error = "未知工具" }),
|
|
};
|
|
},
|
|
onToken,
|
|
onToolRunning,
|
|
ct);
|
|
|
|
return new AgentTurnResult(response.Text, created);
|
|
}
|
|
|
|
public async Task<IReadOnlyList<ParsedBill>> ParseDraftsAsync(
|
|
long userId,
|
|
string text,
|
|
CancellationToken ct = default)
|
|
{
|
|
if (!llm.IsEnabled)
|
|
throw new InvalidOperationException("AI 功能尚未配置");
|
|
|
|
var drafts = new List<ParsedBill>();
|
|
await llm.RunAgentAsync(
|
|
"""
|
|
你是记账草稿解析器。只有金额和收入/支出方向都明确时才调用 prepare_transactions。
|
|
收入包括赚到、工资到账、奖金、兼职、稿费、红包、报销、退款、理财收益、收款等。
|
|
“100”这类裸金额、查询问题和普通聊天都不要调用工具。
|
|
可以一次提取多笔交易。不得把收入写成支出，也不得虚构金额。
|
|
""",
|
|
text,
|
|
DraftTools,
|
|
async (call, toolCt) =>
|
|
{
|
|
if (call.Name != "prepare_transactions")
|
|
return Serialize(new { ok = false, error = "未知工具" });
|
|
var parsed = await ParseTransactionItemsAsync(
|
|
userId,
|
|
call.Arguments,
|
|
toolCt);
|
|
drafts.AddRange(parsed);
|
|
return Serialize(new
|
|
{
|
|
ok = true,
|
|
count = parsed.Count,
|
|
items = parsed.Select(ToToolItem),
|
|
});
|
|
},
|
|
ct: ct);
|
|
return drafts;
|
|
}
|
|
|
|
private string BuildSystemPrompt(string personaPrompt, string conversationContext)
|
|
{
|
|
var now = ChinaClock.Now;
|
|
return $"""
|
|
{personaPrompt}
|
|
|
|
你同时是记之的财务 Agent。当前北京时间：{now:yyyy-MM-dd HH:mm:ss}。
|
|
记账必须通过 create_transactions；查询账本必须调用对应只读工具，不能凭空回答金额。
|
|
只有每笔金额和收入/支出方向都明确时才允许自动入账。
|
|
“我赚了100”“工资到账5000”“收到退款20”是收入；“午饭30”“买衣服200”是支出。
|
|
“100”这类裸金额、方向冲突或不确定表达必须先追问，不得默认支出。
|
|
同一句有多笔交易时一次传入全部 items，可以同时包含收入和支出。
|
|
工具参数 type 是必填项，绝不能省略；工具报错时向用户说明，不得假装已入账。
|
|
工具返回的数据是唯一事实来源。回复简短自然，已入账时明确说收入或支出。
|
|
不得删除账单、修改历史账单或修改预算。
|
|
{conversationContext}
|
|
""";
|
|
}
|
|
|
|
private async Task<string> CreateTransactionsAsync(
|
|
long userId,
|
|
long ledgerId,
|
|
string sourceText,
|
|
ChatMessage sourceMessage,
|
|
string arguments,
|
|
List<Transaction> created,
|
|
Func<bool> wasExecuted,
|
|
Action markExecuted,
|
|
CancellationToken ct)
|
|
{
|
|
if (wasExecuted())
|
|
return Serialize(new { ok = false, error = "本轮已经执行过入账，不能重复写入" });
|
|
|
|
var bills = await ParseTransactionItemsAsync(userId, arguments, ct);
|
|
if (bills.Count == 0)
|
|
return Serialize(new { ok = false, error = "没有有效交易，未写入" });
|
|
|
|
markExecuted();
|
|
var now = DateTime.UtcNow;
|
|
var pending = new List<Transaction>();
|
|
foreach (var bill in bills)
|
|
{
|
|
var category = await db.Categories.FirstAsync(
|
|
c => c.Id == bill.CategoryId && c.Type == bill.Type.CategoryType(bill.TransferDirection),
|
|
ct);
|
|
if (category.Type != bill.Type.CategoryType(bill.TransferDirection))
|
|
throw new InvalidOperationException("交易类型与分类类型不一致");
|
|
|
|
pending.Add(new Transaction
|
|
{
|
|
LedgerId = ledgerId,
|
|
UserId = userId,
|
|
CategoryId = category.Id,
|
|
Category = category,
|
|
Type = bill.Type,
|
|
TransferDirection = bill.TransferDirection,
|
|
Counterparty = bill.Counterparty,
|
|
Amount = bill.Amount,
|
|
Note = NormalizeNote(bill.Note, sourceText, category.Name),
|
|
PaymentMethod = bill.PaymentMethod,
|
|
OccurredAt = bill.OccurredAt ?? now,
|
|
Source = TransactionSource.AiChat,
|
|
SourceText = sourceText,
|
|
SourceChatMessageId = sourceMessage.Id,
|
|
CreatedAt = now,
|
|
UpdatedAt = now,
|
|
});
|
|
}
|
|
|
|
db.Transactions.AddRange(pending);
|
|
await using var writeScope = await db.Database.BeginTransactionAsync(ct);
|
|
try
|
|
{
|
|
await db.SaveChangesAsync(ct);
|
|
await budgetPush.EvaluateAsync(userId, pending
|
|
.Where(transaction => transaction.Type.IsExpense(transaction.TransferDirection))
|
|
.Select(transaction => new BudgetExpenseChange(
|
|
transaction.LedgerId,
|
|
transaction.CategoryId,
|
|
transaction.OccurredAt,
|
|
transaction.Amount)), ct);
|
|
await db.SaveChangesAsync(ct);
|
|
await writeScope.CommitAsync(ct);
|
|
}
|
|
catch
|
|
{
|
|
await writeScope.RollbackAsync(ct);
|
|
foreach (var transaction in pending)
|
|
db.Entry(transaction).State = EntityState.Detached;
|
|
throw;
|
|
}
|
|
created.AddRange(pending);
|
|
|
|
return Serialize(new
|
|
{
|
|
ok = true,
|
|
count = created.Count,
|
|
items = created.Select(transaction => new
|
|
{
|
|
id = transaction.Id,
|
|
type = transaction.Type.ToWire(),
|
|
transferDirection = transaction.TransferDirection.ToWire(),
|
|
transaction.Counterparty,
|
|
amount = transaction.Amount,
|
|
categoryName = transaction.Category.Name,
|
|
note = transaction.Note,
|
|
}),
|
|
});
|
|
}
|
|
|
|
private async Task<List<ParsedBill>> ParseTransactionItemsAsync(
|
|
long userId,
|
|
string arguments,
|
|
CancellationToken ct)
|
|
{
|
|
using var document = JsonDocument.Parse(arguments);
|
|
var root = document.RootElement;
|
|
if (root.ValueKind != JsonValueKind.Object ||
|
|
!root.TryGetProperty("items", out var items) ||
|
|
items.ValueKind != JsonValueKind.Array)
|
|
{
|
|
throw new InvalidOperationException("工具参数缺少 items");
|
|
}
|
|
if (items.GetArrayLength() is < 1 or > 10)
|
|
throw new InvalidOperationException("每次只能处理 1 到 10 笔交易");
|
|
|
|
var bills = new List<ParsedBill>();
|
|
foreach (var item in items.EnumerateArray())
|
|
{
|
|
var typeText = RequiredString(item, "type").ToLowerInvariant();
|
|
var type = typeText switch
|
|
{
|
|
"income" => TransactionType.Income,
|
|
"expense" => TransactionType.Expense,
|
|
"transfer" => TransactionType.Transfer,
|
|
_ => throw new InvalidOperationException(
|
|
"交易 type 必须是 income、expense 或 transfer"),
|
|
};
|
|
TransferDirection? transferDirection = null;
|
|
if (type == TransactionType.Transfer)
|
|
{
|
|
transferDirection = RequiredString(item, "transferDirection") switch
|
|
{
|
|
"in" => TransferDirection.In,
|
|
"out" => TransferDirection.Out,
|
|
_ => throw new InvalidOperationException("转账方向必须是 in 或 out"),
|
|
};
|
|
}
|
|
if (!item.TryGetProperty("amount", out var amountNode) ||
|
|
!amountNode.TryGetDecimal(out var amount) ||
|
|
amount <= 0)
|
|
{
|
|
throw new InvalidOperationException("交易金额必须大于 0");
|
|
}
|
|
|
|
var categoryName = RequiredString(item, "categoryName").Trim();
|
|
var note = RequiredString(item, "note").Trim();
|
|
if (categoryName.Length > 20) categoryName = categoryName[..20];
|
|
if (note.Length > 30) note = note[..30];
|
|
var category = await ResolveCategoryAsync(
|
|
userId,
|
|
type.CategoryType(transferDirection),
|
|
categoryName,
|
|
ct);
|
|
|
|
string? paymentMethod = null;
|
|
if (item.TryGetProperty("paymentMethod", out var paymentNode) &&
|
|
paymentNode.ValueKind == JsonValueKind.String)
|
|
{
|
|
paymentMethod = paymentNode.GetString()?.Trim();
|
|
if (paymentMethod?.Length > 20)
|
|
paymentMethod = paymentMethod[..20];
|
|
}
|
|
|
|
DateTime? occurredAt = null;
|
|
if (item.TryGetProperty("occurredAt", out var occurredNode) &&
|
|
occurredNode.ValueKind == JsonValueKind.String &&
|
|
!string.IsNullOrWhiteSpace(occurredNode.GetString()))
|
|
{
|
|
if (!DateTimeOffset.TryParse(
|
|
occurredNode.GetString(),
|
|
CultureInfo.InvariantCulture,
|
|
DateTimeStyles.AssumeLocal,
|
|
out var parsedTime))
|
|
{
|
|
throw new InvalidOperationException("交易时间格式无效");
|
|
}
|
|
occurredAt = parsedTime.UtcDateTime;
|
|
}
|
|
|
|
bills.Add(new ParsedBill(
|
|
type,
|
|
category.Id,
|
|
category.Name,
|
|
string.IsNullOrWhiteSpace(note) ? category.Name : note,
|
|
amount,
|
|
paymentMethod,
|
|
occurredAt,
|
|
transferDirection,
|
|
OptionalString(item, "counterparty", 100)));
|
|
}
|
|
return bills;
|
|
}
|
|
|
|
private async Task<string> FinancialSummaryAsync(
|
|
long userId,
|
|
long ledgerId,
|
|
string arguments,
|
|
CancellationToken ct)
|
|
{
|
|
using var document = JsonDocument.Parse(arguments);
|
|
var period = RequiredString(document.RootElement, "period");
|
|
var (start, end, label) = ResolvePeriod(period);
|
|
var transactions = await db.Transactions
|
|
.Include(t => t.Category)
|
|
.Where(t => t.UserId == userId &&
|
|
t.LedgerId == ledgerId &&
|
|
t.OccurredAt >= start &&
|
|
t.OccurredAt < end)
|
|
.ToListAsync(ct);
|
|
|
|
var income = transactions
|
|
.Where(t => t.Type.IsIncome(t.TransferDirection))
|
|
.Sum(t => t.Amount);
|
|
var expense = transactions
|
|
.Where(t => t.Type.IsExpense(t.TransferDirection))
|
|
.Sum(t => t.Amount);
|
|
var categories = transactions
|
|
.GroupBy(t => new
|
|
{
|
|
EffectiveType = t.Type.IsIncome(t.TransferDirection) ? "income" : "expense",
|
|
t.Category.Name,
|
|
})
|
|
.Select(group => new
|
|
{
|
|
type = group.Key.EffectiveType,
|
|
categoryName = group.Key.Name,
|
|
amount = group.Sum(t => t.Amount),
|
|
})
|
|
.OrderByDescending(item => item.amount)
|
|
.ToList();
|
|
|
|
return Serialize(new
|
|
{
|
|
ok = true,
|
|
period = label,
|
|
income,
|
|
expense,
|
|
balance = income - expense,
|
|
count = transactions.Count,
|
|
categories,
|
|
});
|
|
}
|
|
|
|
private async Task<string> ListTransactionsAsync(
|
|
long userId,
|
|
long ledgerId,
|
|
string arguments,
|
|
CancellationToken ct)
|
|
{
|
|
using var document = JsonDocument.Parse(arguments);
|
|
var root = document.RootElement;
|
|
var period = RequiredString(root, "period");
|
|
var (start, end, label) = ResolvePeriod(period);
|
|
var query = db.Transactions
|
|
.Include(t => t.Category)
|
|
.Where(t => t.UserId == userId &&
|
|
t.LedgerId == ledgerId &&
|
|
t.OccurredAt >= start &&
|
|
t.OccurredAt < end);
|
|
|
|
if (root.TryGetProperty("type", out var typeNode) &&
|
|
typeNode.ValueKind == JsonValueKind.String)
|
|
{
|
|
var type = typeNode.GetString() switch
|
|
{
|
|
"income" => TransactionType.Income,
|
|
"expense" => TransactionType.Expense,
|
|
"transfer" => TransactionType.Transfer,
|
|
_ => throw new InvalidOperationException("筛选类型无效"),
|
|
};
|
|
query = query.Where(t => t.Type == type);
|
|
}
|
|
if (root.TryGetProperty("categoryName", out var categoryNode) &&
|
|
categoryNode.ValueKind == JsonValueKind.String &&
|
|
!string.IsNullOrWhiteSpace(categoryNode.GetString()))
|
|
{
|
|
var categoryName = categoryNode.GetString()!.Trim();
|
|
query = query.Where(t => t.Category.Name == categoryName);
|
|
}
|
|
var limit = root.TryGetProperty("limit", out var limitNode) &&
|
|
limitNode.TryGetInt32(out var requestedLimit)
|
|
? Math.Clamp(requestedLimit, 1, 10)
|
|
: 10;
|
|
var transactions = await query
|
|
.OrderByDescending(t => t.OccurredAt)
|
|
.Take(limit)
|
|
.ToListAsync(ct);
|
|
|
|
return Serialize(new
|
|
{
|
|
ok = true,
|
|
period = label,
|
|
count = transactions.Count,
|
|
items = transactions.Select(transaction => new
|
|
{
|
|
id = transaction.Id,
|
|
type = transaction.Type.ToWire(),
|
|
transferDirection = transaction.TransferDirection.ToWire(),
|
|
transaction.Counterparty,
|
|
transaction.Amount,
|
|
categoryName = transaction.Category.Name,
|
|
transaction.Note,
|
|
occurredAt = transaction.OccurredAt,
|
|
}),
|
|
});
|
|
}
|
|
|
|
private async Task<string> BudgetStatusAsync(
|
|
long userId,
|
|
long ledgerId,
|
|
string arguments,
|
|
CancellationToken ct)
|
|
{
|
|
using var document = JsonDocument.Parse(arguments);
|
|
var root = document.RootElement;
|
|
if (!root.TryGetProperty("year", out var yearNode) ||
|
|
!yearNode.TryGetInt32(out var year) ||
|
|
!root.TryGetProperty("month", out var monthNode) ||
|
|
!monthNode.TryGetInt32(out var month) ||
|
|
year is < 2000 or > 2200 ||
|
|
month is < 1 or > 12)
|
|
{
|
|
throw new InvalidOperationException("预算年月无效");
|
|
}
|
|
|
|
var period = year * 100 + month;
|
|
var (start, end) = ChinaClock.MonthRangeUtc(year, month);
|
|
var budgetRows = await db.Budgets
|
|
.Where(b => b.UserId == userId &&
|
|
b.LedgerId == ledgerId &&
|
|
(b.Period == period || b.Period == 0))
|
|
.ToListAsync(ct);
|
|
var effective = budgetRows
|
|
.GroupBy(b => b.CategoryId)
|
|
.Select(group => group
|
|
.OrderByDescending(b => b.Period == period)
|
|
.First())
|
|
.ToList();
|
|
var categoryIds = effective
|
|
.Where(budget => budget.CategoryId.HasValue)
|
|
.Select(budget => budget.CategoryId!.Value)
|
|
.Distinct()
|
|
.ToList();
|
|
var categoryNames = await db.Categories
|
|
.Where(category => categoryIds.Contains(category.Id))
|
|
.ToDictionaryAsync(category => category.Id, category => category.Name, ct);
|
|
var expenses = await db.Transactions
|
|
.Where(t => t.UserId == userId &&
|
|
t.LedgerId == ledgerId &&
|
|
(t.Type == TransactionType.Expense ||
|
|
t.Type == TransactionType.Transfer &&
|
|
t.TransferDirection == TransferDirection.Out) &&
|
|
t.OccurredAt >= start &&
|
|
t.OccurredAt < end)
|
|
.Select(t => new { t.CategoryId, t.Amount })
|
|
.ToListAsync(ct);
|
|
var spentByCategory = expenses
|
|
.GroupBy(t => t.CategoryId)
|
|
.ToDictionary(group => group.Key, group => group.Sum(t => t.Amount));
|
|
var totalSpent = expenses.Sum(t => t.Amount);
|
|
|
|
return Serialize(new
|
|
{
|
|
ok = true,
|
|
year,
|
|
month,
|
|
totalSpent,
|
|
budgets = effective.Select(budget => new
|
|
{
|
|
categoryName = budget.CategoryId.HasValue
|
|
? categoryNames.GetValueOrDefault(budget.CategoryId.Value, "其他")
|
|
: "总预算",
|
|
amount = budget.Amount,
|
|
spent = budget.CategoryId.HasValue
|
|
? spentByCategory.GetValueOrDefault(budget.CategoryId.Value)
|
|
: totalSpent,
|
|
remaining = budget.Amount - (
|
|
budget.CategoryId.HasValue
|
|
? spentByCategory.GetValueOrDefault(budget.CategoryId.Value)
|
|
: totalSpent),
|
|
recurring = budget.Period == 0,
|
|
}),
|
|
});
|
|
}
|
|
|
|
private static string NormalizeNote(
|
|
string note,
|
|
string sourceText,
|
|
string categoryName)
|
|
{
|
|
var trimmed = note.Trim();
|
|
var comparableNote = string.Concat(trimmed.Where(char.IsLetterOrDigit));
|
|
var comparableSource = string.Concat(
|
|
sourceText.Trim().Where(char.IsLetterOrDigit));
|
|
if (string.Equals(
|
|
comparableNote,
|
|
comparableSource,
|
|
StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return categoryName;
|
|
}
|
|
return trimmed.Length > 16 ? trimmed[..16] : trimmed;
|
|
}
|
|
|
|
private async Task<Category> ResolveCategoryAsync(
|
|
long userId,
|
|
TransactionType type,
|
|
string requestedName,
|
|
CancellationToken ct)
|
|
{
|
|
var category = await db.Categories
|
|
.Where(c => !c.IsDeleted &&
|
|
c.Type == type &&
|
|
c.Name == requestedName &&
|
|
(c.UserId == null || c.UserId == userId))
|
|
.OrderByDescending(c => c.UserId == userId)
|
|
.FirstOrDefaultAsync(ct);
|
|
return category ?? await db.Categories.FirstAsync(
|
|
c => !c.IsDeleted &&
|
|
c.UserId == null &&
|
|
c.Type == type &&
|
|
c.Name == "其他",
|
|
ct);
|
|
}
|
|
|
|
private async Task<long> DefaultLedgerIdAsync(long userId, CancellationToken ct) =>
|
|
await db.Ledgers
|
|
.Where(l => l.OwnerId == userId && l.IsDefault)
|
|
.Select(l => l.Id)
|
|
.FirstAsync(ct);
|
|
|
|
private static object ToToolItem(ParsedBill bill) => new
|
|
{
|
|
type = bill.Type.ToWire(),
|
|
transferDirection = bill.TransferDirection.ToWire(),
|
|
bill.Counterparty,
|
|
bill.Amount,
|
|
bill.CategoryName,
|
|
bill.Note,
|
|
bill.PaymentMethod,
|
|
occurredAt = bill.OccurredAt,
|
|
};
|
|
|
|
private static string RequiredString(JsonElement root, string name)
|
|
{
|
|
if (!root.TryGetProperty(name, out var node) ||
|
|
node.ValueKind != JsonValueKind.String ||
|
|
string.IsNullOrWhiteSpace(node.GetString()))
|
|
{
|
|
throw new InvalidOperationException($"工具参数缺少 {name}");
|
|
}
|
|
return node.GetString()!;
|
|
}
|
|
|
|
private static string? OptionalString(JsonElement root, string name, int maxLength)
|
|
{
|
|
if (!root.TryGetProperty(name, out var node) || node.ValueKind != JsonValueKind.String)
|
|
return null;
|
|
var value = node.GetString()?.Trim();
|
|
if (string.IsNullOrEmpty(value)) return null;
|
|
return value.Length <= maxLength ? value : value[..maxLength];
|
|
}
|
|
|
|
private static (DateTime Start, DateTime End, string Label) ResolvePeriod(
|
|
string period)
|
|
{
|
|
var localNow = ChinaClock.Now;
|
|
var today = localNow.Date;
|
|
DateTime startLocal;
|
|
DateTime endLocal;
|
|
string label;
|
|
switch (period)
|
|
{
|
|
case "today":
|
|
startLocal = today;
|
|
endLocal = today.AddDays(1);
|
|
label = "今天";
|
|
break;
|
|
case "yesterday":
|
|
startLocal = today.AddDays(-1);
|
|
endLocal = today;
|
|
label = "昨天";
|
|
break;
|
|
case "this_week":
|
|
var offset = ((int)today.DayOfWeek + 6) % 7;
|
|
startLocal = today.AddDays(-offset);
|
|
endLocal = startLocal.AddDays(7);
|
|
label = "本周";
|
|
break;
|
|
case "this_month":
|
|
startLocal = new DateTime(today.Year, today.Month, 1);
|
|
endLocal = startLocal.AddMonths(1);
|
|
label = "本月";
|
|
break;
|
|
case "last_month":
|
|
endLocal = new DateTime(today.Year, today.Month, 1);
|
|
startLocal = endLocal.AddMonths(-1);
|
|
label = "上月";
|
|
break;
|
|
case "this_year":
|
|
startLocal = new DateTime(today.Year, 1, 1);
|
|
endLocal = startLocal.AddYears(1);
|
|
label = "今年";
|
|
break;
|
|
default:
|
|
throw new InvalidOperationException("查询周期无效");
|
|
}
|
|
return (ChinaClock.ToUtc(startLocal), ChinaClock.ToUtc(endLocal), label);
|
|
}
|
|
|
|
private static object Schema(string json) =>
|
|
JsonSerializer.Deserialize<JsonElement>(json);
|
|
|
|
private static string Serialize(object value) =>
|
|
JsonSerializer.Serialize(value, JsonOptions);
|
|
}
|