婚前协议模板

复制import json
from typing import List, Dict

# 模拟婚前协议模板的核心数据结构
class PremaritalAgreement:
    def __init__(self, party_a: str, party_b: str):
        self.party_a = party_a
        self.party_b = party_b
        self.properties: List[Dict] = []  # 财产清单
        self.debts: List[Dict] = []       # 债务清单
        self.children: List[Dict] = []    # 子女抚养安排

    def add_property(self, name: str, value: float, owner: str):
        """添加财产条目"""
        self.properties.append({
            "name": name,
            "value": value,
            "owner": owner,  # 'joint' 或 'separate'
            "disposition": ""  # 处置方式（如：归一方所有、出售后平分）
        })

    def add_debt(self, name: str, amount: float, responsible: str):
        """添加债务条目"""
        self.debts.append({
            "name": name,
            "amount": amount,
            "responsible": responsible  # 'party_a', 'party_b', 'joint'
        })

    def add_child_arrangement(self, child_name: str, custody: str, support: float):
        """添加子女抚养安排"""
        self.children.append({
            "child_name": child_name,
            "custody": custody,  # 'sole' 或 'joint'
            "monthly_support": support
        })

    def generate_summary(self) -> Dict:
        """生成协议摘要（模拟模板输出）"""
        total_assets = sum(p['value'] for p in self.properties)
        total_debts = sum(d['amount'] for d in self.debts)
        return {
            "parties": f"{self.party_a} 与 {self.party_b}",
            "property_count": len(self.properties),
            "total_assets": total_assets,
            "debt_count": len(self.debts),
            "total_debts": total_debts,
            "child_count": len(self.children),
            "net_worth": total_assets - total_debts
        }

# 使用示例
agreement = PremaritalAgreement("张三", "李四")
agreement.add_property("房产A", 2000000, "joint")
agreement.add_property("车辆", 300000, "separate")
agreement.add_debt("房贷", 800000, "joint")
agreement.add_child_arrangement("张小宝", "joint", 5000)

summary = agreement.generate_summary()
print(json.dumps(summary, ensure_ascii=False, indent=2))
# 输出：
# {
#   "parties": "张三 与 李四",
#   "property_count": 2,
#   "total_assets": 2300000,
#   "debt_count": 1,
#   "total_debts": 800000,
#   "child_count": 1,
#   "net_worth": 1500000
# }

复制package main

import (
	"encoding/json"
	"fmt"
)

// Property 财产条目
type Property struct {
	Name        string  `json:"name"`
	Value       float64 `json:"value"`
	Owner       string  `json:"owner"`       // "joint" 或 "separate"
	Disposition string  `json:"disposition"` // 处置方式
}

// Debt 债务条目
type Debt struct {
	Name        string  `json:"name"`
	Amount      float64 `json:"amount"`
	Responsible string  `json:"responsible"` // "party_a", "party_b", "joint"
}

// ChildArrangement 子女抚养安排
type ChildArrangement struct {
	ChildName     string  `json:"child_name"`
	Custody       string  `json:"custody"`        // "sole" 或 "joint"
	MonthlySupport float64 `json:"monthly_support"`
}

// Agreement 婚前协议
type Agreement struct {
	PartyA   string             `json:"party_a"`
	PartyB   string             `json:"party_b"`
	Properties []Property       `json:"properties"`
	Debts      []Debt           `json:"debts"`
	Children   []ChildArrangement `json:"children"`
}

// Summary 生成协议摘要
func (a *Agreement) Summary() map[string]interface{} {
	totalAssets := 0.0
	for _, p := range a.Properties {
		totalAssets += p.Value
	}
	totalDebts := 0.0
	for _, d := range a.Debts {
		totalDebts += d.Amount
	}
	return map[string]interface{}{
		"parties":       fmt.Sprintf("%s 与 %s", a.PartyA, a.PartyB),
		"property_count": len(a.Properties),
		"total_assets":  totalAssets,
		"debt_count":    len(a.Debts),
		"total_debts":   totalDebts,
		"child_count":   len(a.Children),
		"net_worth":     totalAssets - totalDebts,
	}
}

func main() {
	agreement := Agreement{
		PartyA: "张三",
		PartyB: "李四",
		Properties: []Property{
			{Name: "房产A", Value: 2000000, Owner: "joint"},
			{Name: "车辆", Value: 300000, Owner: "separate"},
		},
		Debts: []Debt{
			{Name: "房贷", Amount: 800000, Responsible: "joint"},
		},
		Children: []ChildArrangement{
			{ChildName: "张小宝", Custody: "joint", MonthlySupport: 5000},
		},
	}

	summary := agreement.Summary()
	jsonBytes, _ := json.MarshalIndent(summary, "", "  ")
	fmt.Println(string(jsonBytes))
	// 输出：
	// {
	//   "child_count": 1,
	//   "debt_count": 1,
	//   "net_worth": 1500000,
	//   "parties": "张三 与 李四",
	//   "property_count": 2,
	//   "total_assets": 2300000,
	//   "total_debts": 800000
	// }
}

复制// 模拟婚前协议模板的数据处理
class PremaritalAgreement {
  constructor(partyA, partyB) {
    this.partyA = partyA;
    this.partyB = partyB;
    this.properties = []; // 财产清单
    this.debts = [];      // 债务清单
    this.children = [];   // 子女抚养安排
  }

  // 添加财产
  addProperty(name, value, owner) {
    this.properties.push({ name, value, owner, disposition: '' });
  }

  // 添加债务
  addDebt(name, amount, responsible) {
    this.debts.push({ name, amount, responsible });
  }

  // 添加子女抚养安排
  addChildArrangement(childName, custody, monthlySupport) {
    this.children.push({ childName, custody, monthlySupport });
  }

  // 生成摘要
  generateSummary() {
    const totalAssets = this.properties.reduce((sum, p) => sum + p.value, 0);
    const totalDebts = this.debts.reduce((sum, d) => sum + d.amount, 0);
    return {
      parties: `${this.partyA} 与 ${this.partyB}`,
      propertyCount: this.properties.length,
      totalAssets,
      debtCount: this.debts.length,
      totalDebts,
      childCount: this.children.length,
      netWorth: totalAssets - totalDebts
    };
  }
}

// 使用示例
const agreement = new PremaritalAgreement('张三', '李四');
agreement.addProperty('房产A', 2000000, 'joint');
agreement.addProperty('车辆', 300000, 'separate');
agreement.addDebt('房贷', 800000, 'joint');
agreement.addChildArrangement('张小宝', 'joint', 5000);

console.log(JSON.stringify(agreement.generateSummary(), null, 2));
// 输出：
// {
//   "parties": "张三 与 李四",
//   "propertyCount": 2,
//   "totalAssets": 2300000,
//   "debtCount": 1,
//   "totalDebts": 800000,
//   "childCount": 1,
//   "netWorth": 1500000
// }