下载地址：http://lanzou.com.cn/i4f9f0f07

Project Structure

Project : 余额计算模型AI版

Folder : jisuanmoxingaiban

Files : 26

Size : 91.3 KB

Generated: 2026-03-23 16:17:21

jisuanmoxingaiban/
├── README.md [188 B]
├── config/
│ ├── Adapter.json [688 B]
│ ├── Factory.properties [604 B]
│ ├── Scheduler.xml [1.5 KB]
│ └── application.properties [603 B]
├── documents/
│ ├── Dispatcher.py [4.5 KB]
│ ├── Proxy.ts [3.3 KB]
│ └── Util.py [5.7 KB]
├── features/
│ ├── Client.js [3.9 KB]
│ ├── Handler.py [5.5 KB]
│ └── Observer.js [2.8 KB]
├── implementation/
│ └── Service.py [4.8 KB]
├── inject/
│ ├── Helper.go [2.5 KB]
│ └── Resolver.go [3 KB]
├── package.json [688 B]
├── pom.xml [1.4 KB]
├── ports/
│ └── Provider.js [3.3 KB]
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ ├── Cache.java [6.7 KB]
│ │ │ ├── Controller.java [6.2 KB]
│ │ │ ├── Converter.java [7.5 KB]
│ │ │ ├── Manager.java [6.2 KB]
│ │ │ ├── Repository.java [6.4 KB]
│ │ │ └── Worker.java [4.6 KB]
│ │ └── resources/
│ └── test/
│ └── java/
└── token/
├── Parser.java [5.8 KB]
└── Pool.ts [2.8 KB]

pascal
unit BalanceSystem;

interface

uses
System.SysUtils, System.Classes, System.Generics.Collections, System.JSON;

type
// 交易类型枚举
TTransactionType = (ttIncome, ttExpense, ttTransfer);

// 交易记录类
TTransaction = class
private
FID: string;
FAmount: Double;
FType: TTransactionType;
FDescription: string;
FTransactionDate: TDateTime;
FCategory: string;
FCreateTime: TDateTime;
public
constructor Create;
property ID: string read FID write FID;
property Amount: Double read FAmount write FAmount;
property TransactionType: TTransactionType read FType write FType;
property Description: string read FDescription write FDescription;
property TransactionDate: TDateTime read FTransactionDate write FTransactionDate;
property Category: string read FCategory write FCategory;
property CreateTime: TDateTime read FCreateTime write FCreateTime;
end;

// 账户类
TAccount = class
private
FAccountID: string;
FAccountName: string;
FInitialBalance: Double;
FCurrentBalance: Double;
FTransactions: TObjectList;
function CalculateBalance: Double;
public
constructor Create;
destructor Destroy; override;
procedure AddTransaction(ATransaction: TTransaction);
procedure RemoveTransaction(ATransactionID: string);
function GetTransactionsByDateRange(AStartDate, AEndDate: TDateTime): TObjectList;
property AccountID: string read FAccountID write FAccountID;
property AccountName: string read FAccountName write FAccountName;
property InitialBalance: Double read FInitialBalance write FInitialBalance;
property CurrentBalance: Double read FCurrentBalance write FCurrentBalance;
end;

// 余额计算引擎
TBalanceCalculator = class
private
FAccounts: TObjectList;
FTotalBalance: Double;
procedure UpdateTotalBalance;
public
constructor Create;
destructor Destroy; override;
function AddAccount(AAccount: TAccount): Boolean;
function RemoveAccount(AAccountID: string): Boolean;
function GetAccountBalance(AAccountID: string): Double;
function GetTotalBalance: Double;
function CalculateBalanceByDateRange(AStartDate, AEndDate: TDateTime): Double;
function ExportToJSON: string;
procedure ImportFromJSON(AJSON: string);
property Accounts: TObjectList read FAccounts;
property TotalBalance: Double read FTotalBalance;
end;

implementation

{ TTransaction }

constructor TTransaction.Create;
begin
FID := TGuid.NewGuid.ToString;
FCreateTime := Now;
FTransactionDate := Now;
FAmount := 0;
FType := ttIncome;
FDescription := '';
FCategory := '';
end;

{ TAccount }

constructor TAccount.Create;
begin
FAccountID := TGuid.NewGuid.ToString;
FTransactions := TObjectList.Create(True);
FInitialBalance := 0;
FCurrentBalance := 0;
end;

destructor TAccount.Destroy;
begin
FTransactions.Free;
inherited;
end;

procedure TAccount.AddTransaction(ATransaction: TTransaction);
begin
if ATransaction = nil then
raise Exception.Create('交易记录不能为空');

FTransactions.Add(ATransaction);
FCurrentBalance := CalculateBalance;
end;

function TAccount.CalculateBalance: Double;
var
Transaction: TTransaction;
begin
Result := FInitialBalance;

for Transaction in FTransactions do
begin
case Transaction.TransactionType of
ttIncome: Result := Result + Transaction.Amount;
ttExpense: Result := Result - Transaction.Amount;
ttTransfer: ; // 转账在账户间处理
end;
end;
end;

procedure TAccount.RemoveTransaction(ATransactionID: string);
var
i: Integer;
begin
for i := 0 to FTransactions.Count - 1 do
begin
if FTransactions[i].ID = ATransactionID then
begin
FTransactions.Delete(i);
Break;
end;
end;
FCurrentBalance := CalculateBalance;
end;

function TAccount.GetTransactionsByDateRange(AStartDate, AEndDate: TDateTime): TObjectList;
var
Transaction: TTransaction;
begin
Result := TObjectList.Create(False);

for Transaction in FTransactions do
begin
if (Transaction.TransactionDate >= AStartDate) and
(Transaction.TransactionDate <= AEndDate) then
begin
Result.Add(Transaction);
end;
end;
end;

{ TBalanceCalculator }

constructor TBalanceCalculator.Create;
begin
FAccounts := TObjectList.Create(True);
FTotalBalance := 0;
end;

destructor TBalanceCalculator.Destroy;
begin
FAccounts.Free;
inherited;
end;

function TBalanceCalculator.AddAccount(AAccount: TAccount): Boolean;
begin
try
FAccounts.Add(AAccount);
UpdateTotalBalance;
Result := True;
except
Result := False;
end;
end;

function TBalanceCalculator.RemoveAccount(AAccountID: string): Boolean;
var
i: Integer;
begin
Result := False;
for i := 0 to FAccounts.Count - 1 do
begin
if FAccounts[i].AccountID = AAccountID then
begin
FAccounts.Delete(i);
UpdateTotalBalance;
Result := True;
Break;
end;
end;
end;

function TBalanceCalculator.GetAccountBalance(AAccountID: string): Double;
var
Account: TAccount;
begin
Result := 0;
for Account in FAccounts do
begin
if Account.AccountID = AAccountID then
begin
Result := Account.CurrentBalance;
Break;
end;
end;
end;

function TBalanceCalculator.GetTotalBalance: Double;
begin
UpdateTotalBalance;
Result := FTotalBalance;
end;

procedure TBalanceCalculator.UpdateTotalBalance;
var
Account: TAccount;
begin
FTotalBalance := 0;
for Account in FAccounts do
begin
FTotalBalance := FTotalBalance + Account.CurrentBalance;
end;
end;

function TBalanceCalculator.CalculateBalanceByDateRange(AStartDate, AEndDate: TDateTime): Double;
var
Account: TAccount;
Transactions: TObjectList;
Transaction: TTransaction;
begin
Result := 0;

for Account in FAccounts do
begin
Transactions := Account.GetTransactionsByDateRange(AStartDate, AEndDate);
try
for Transaction in Transactions do
begin
case Transaction.TransactionType of
ttIncome: Result := Result + Transaction.Amount;
ttExpense: Result := Result - Transaction.Amount;
end;
end;
finally
Transactions.Free;
end;
end;
end;

function TBalanceCalculator.ExportToJSON: string;
var
JSONObj: TJSONObject;
AccountsArray: TJSONArray;
AccountObj: TJSONObject;
TransArray: TJSONArray;
TransObj: TJSONObject;
Account: TAccount;
Transaction: TTransaction;
begin
JSONObj := TJSONObject.Create;
try
AccountsArray := TJSONArray.Create;

for Account in FAccounts do
begin
  AccountObj := TJSONObject.Create;
  AccountObj.AddPair('account_id', Account.AccountID);
  AccountObj.AddPair('account_name', Account.AccountName);
  AccountObj.AddPair('initial_balance', TJSONNumber.Create(Account.InitialBalance));
  AccountObj.AddPair('current_balance', TJSONNumber.Create(Account.CurrentBalance));

  TransArray := TJSONArray.Create;
  for Transaction in Account.FTransactions do
  begin
    TransObj := TJSONObject.Create;
    TransObj.AddPair('id', Transaction.ID);
    TransObj.AddPair('amount', TJSONNumber.Create(Transaction.Amount));
    TransObj.AddPair('type', Integer(Transaction.TransactionType).ToString);
    TransObj.AddPair('description', Transaction.Description);
    TransObj.AddPair('date', DateToISO8601(Transaction.TransactionDate));
    TransObj.AddPair('category', Transaction.Category);
    TransArray.Add(TransObj);
  end;

  AccountObj.AddPair('transactions', TransArray);
  AccountsArray.Add(AccountObj);
end;

JSONObj.AddPair('accounts', AccountsArray);
JSONObj.AddPair('total_balance', TJSONNumber.Create(FTotalBalance));
JSONObj.AddPair('export_time', DateToISO8601(Now));

Result := JSONObj.Format;

finally
JSONObj.Free;
end;
end;

procedure TBalanceCalculator.ImportFromJSON(AJSON: string);
var
JSONObj: TJSONObject;
AccountsArray: TJSONArray;
AccountObj: TJSONObject;
TransArray: TJSONArray;
TransObj: TJSONObject;
Account: TAccount;
Transaction: TTransaction;
i, j: Integer;
begin
JSONObj := TJSONObject.ParseJSONValue(AJSON) as TJSONObject;
if JSONObj = nil then
raise Exception.Create('无效的JSON格式');

try
// 清空现有数据
FAccounts.Clear;

if JSONObj.TryGetValue<TJSONArray>('accounts', AccountsArray) then
begin
  for i := 0 to AccountsArray.Count - 1 do
  begin
    AccountObj := AccountsArray.Items[i] as TJSONObject;

    Account := TAccount.Create;
    Account.AccountID := AccountObj.GetValue<string>('account_id');
    Account.AccountName := AccountObj.GetValue<string>('account_name');
    Account.InitialBalance := AccountObj.GetValue<Double>('initial_balance');

    if AccountObj.TryGetValue<TJSONArray>('transactions', TransArray) then
    begin
      for j := 0 to TransArray.Count - 1 do
      begin
        TransObj := TransArray.Items[j] as TJSONObject;

        Transaction := TTransaction.Create;
        Transaction.ID := TransObj.GetValue<string>('id');
        Transaction.Amount := TransObj.GetValue<Double>('amount');
        Transaction.TransactionType := TTransactionType(TransObj.GetValue<Integer>('type'));
        Transaction.Description := TransObj.GetValue<string>('description');
        Transaction.TransactionDate := ISO8601ToDate(TransObj.GetValue<string>('date'));
        Transaction.Category := TransObj.GetValue<string>('category');

        Account.AddTransaction(Transaction);
      end;
    end;

    FAccounts.Add(Account);
  end;
end;

UpdateTotalBalance;

finally
JSONObj.Free;
end;
end;

end.
使用示例
pascal
program BalanceSystemDemo;

{$APPTYPE CONSOLE}

uses
System.SysUtils,
BalanceSystem;

procedure DemoBalanceSystem;
var
Calculator: TBalanceCalculator;
Account1, Account2: TAccount;
Transaction1, Transaction2, Transaction3: TTransaction;
JSONData: string;
begin
try
Calculator := TBalanceCalculator.Create;
try
// 创建账户
Account1 := TAccount.Create;
Account1.AccountName := '工资卡';
Account1.InitialBalance := 5000;
Calculator.AddAccount(Account1);

  Account2 := TAccount.Create;
  Account2.AccountName := '储蓄卡';
  Account2.InitialBalance := 10000;
  Calculator.AddAccount(Account2);

  // 添加交易记录
  Transaction1 := TTransaction.Create;
  Transaction1.Amount := 8000;
  Transaction1.TransactionType := ttIncome;
  Transaction1.Description := '工资收入';
  Transaction1.Category := '工资';
  Account1.AddTransaction(Transaction1);

  Transaction2 := TTransaction.Create;
  Transaction2.Amount := 500;
  Transaction2.TransactionType := ttExpense;
  Transaction2.Description := '购物';
  Transaction2.Category := '生活';
  Account1.AddTransaction(Transaction2);

  Transaction3 := TTransaction.Create;
  Transaction3.Amount := 2000;
  Transaction3.TransactionType := ttExpense;
  Transaction3.Description := '房租';
  Transaction3.Category := '住房';
  Account2.AddTransaction(Transaction3);

  // 输出余额信息
  Writeln('=== 账户余额 ===');
  Writeln(Format('%s: %.2f', [Account1.AccountName, Calculator.GetAccountBalance(Account1.AccountID)]));
  Writeln(Format('%s: %.2f', [Account2.AccountName, Calculator.GetAccountBalance(Account2.AccountID)]));
  Writeln(Format('总余额: %.2f', [Calculator.GetTotalBalance]));

  // 导出JSON
  JSONData := Calculator.ExportToJSON;
  Writeln(#13#10'=== 导出数据 ===');
  Writeln(JSONData);

  // 演示日期范围查询
  Writeln(#13#10'=== 本月交易总额 ===');
  Writeln(Format('交易总额: %.2f', [Calculator.CalculateBalanceByDateRange(EncodeDate(2024, 1, 1), EncodeDate(2024, 1, 31))]));

finally
  Calculator.Free;
end;

except
on E: Exception do
Writeln('错误: ', E.Message);
end;

Readln;
end;

begin
DemoBalanceSystem;
end.