564 lines
18 KiB
Dart
564 lines
18 KiB
Dart
import 'dart:io';
|
||
import 'dart:convert';
|
||
import 'package:crypto/crypto.dart';
|
||
import 'package:sqflite/sqflite.dart';
|
||
import 'package:path_provider/path_provider.dart';
|
||
import 'package:intl/intl.dart';
|
||
import '../models/hash_chain_models.dart';
|
||
import '../models/invoice_models.dart';
|
||
import '../models/customer_model.dart';
|
||
import '../models/customer_contact.dart';
|
||
import '../models/sales_summary.dart';
|
||
import 'database_helper.dart';
|
||
import 'activity_log_repository.dart';
|
||
import 'company_repository.dart';
|
||
|
||
class InvoiceRepository {
|
||
final DatabaseHelper _dbHelper = DatabaseHelper();
|
||
final ActivityLogRepository _logRepo = ActivityLogRepository();
|
||
final CompanyRepository _companyRepo = CompanyRepository();
|
||
|
||
Future<void> saveInvoice(Invoice invoice) async {
|
||
final db = await _dbHelper.database;
|
||
|
||
// 正式発行（下書きでない）場合はロックを掛ける
|
||
final companyInfo = await _companyRepo.getCompanyInfo();
|
||
String? sealHash;
|
||
if (companyInfo.sealPath != null) {
|
||
final file = File(companyInfo.sealPath!);
|
||
if (await file.exists()) {
|
||
sealHash = sha256.convert(await file.readAsBytes()).toString();
|
||
}
|
||
}
|
||
final companySnapshot = jsonEncode({
|
||
'name': companyInfo.name,
|
||
'zipCode': companyInfo.zipCode,
|
||
'address': companyInfo.address,
|
||
'tel': companyInfo.tel,
|
||
'fax': companyInfo.fax,
|
||
'email': companyInfo.email,
|
||
'url': companyInfo.url,
|
||
'defaultTaxRate': companyInfo.defaultTaxRate,
|
||
'taxDisplayMode': companyInfo.taxDisplayMode,
|
||
'registrationNumber': companyInfo.registrationNumber,
|
||
});
|
||
|
||
final Invoice toSave = invoice.isDraft ? invoice : invoice.copyWith(isLocked: true);
|
||
|
||
await db.transaction((txn) async {
|
||
// 最新の連絡先をスナップショットする（なければ空）
|
||
CustomerContact? activeContact;
|
||
final contactRows = await txn.query('customer_contacts', where: 'customer_id = ? AND is_active = 1', whereArgs: [invoice.customer.id]);
|
||
if (contactRows.isNotEmpty) {
|
||
activeContact = CustomerContact.fromMap(contactRows.first);
|
||
}
|
||
final Invoice savingWithContact = toSave.copyWith(
|
||
contactVersionId: activeContact?.version,
|
||
contactEmailSnapshot: activeContact?.email,
|
||
contactTelSnapshot: activeContact?.tel,
|
||
contactAddressSnapshot: activeContact?.address,
|
||
companySnapshot: companySnapshot,
|
||
companySealHash: sealHash,
|
||
metaJson: null,
|
||
metaHash: null,
|
||
);
|
||
|
||
Invoice savingWithChain = savingWithContact;
|
||
if (!savingWithContact.isDraft) {
|
||
final previousEntry = await _fetchLatestChainEntry(txn);
|
||
final previousHash = previousEntry?['chain_hash'] as String?;
|
||
final computedHash = _computeChainHash(
|
||
previousHash,
|
||
savingWithContact.contentHash,
|
||
savingWithContact.updatedAt,
|
||
savingWithContact.id,
|
||
);
|
||
savingWithChain = savingWithContact.copyWith(
|
||
previousChainHash: previousHash,
|
||
chainHash: computedHash,
|
||
chainStatus: 'pending',
|
||
);
|
||
} else {
|
||
savingWithChain = savingWithContact.copyWith(
|
||
previousChainHash: null,
|
||
chainHash: null,
|
||
chainStatus: 'draft',
|
||
);
|
||
}
|
||
|
||
// 在庫の調整（更新の場合、以前の数量を戻してから新しい数量を引く）
|
||
final List<Map<String, dynamic>> oldItems = await txn.query(
|
||
'invoice_items',
|
||
where: 'invoice_id = ?',
|
||
whereArgs: [invoice.id],
|
||
);
|
||
|
||
// 旧在庫を戻す
|
||
for (var item in oldItems) {
|
||
if (item['product_id'] != null) {
|
||
await txn.execute(
|
||
'UPDATE products SET stock_quantity = stock_quantity + ? WHERE id = ?',
|
||
[item['quantity'], item['product_id']],
|
||
);
|
||
}
|
||
}
|
||
|
||
// 伝票ヘッダーの保存
|
||
await txn.insert(
|
||
'invoices',
|
||
savingWithChain.toMap(),
|
||
conflictAlgorithm: ConflictAlgorithm.replace,
|
||
);
|
||
|
||
// 既存の明細を一旦削除
|
||
await txn.delete(
|
||
'invoice_items',
|
||
where: 'invoice_id = ?',
|
||
whereArgs: [invoice.id],
|
||
);
|
||
|
||
// 新しい明細の保存と在庫の減算
|
||
for (var item in invoice.items) {
|
||
await txn.insert('invoice_items', item.toMap(invoice.id));
|
||
if (item.productId != null) {
|
||
await txn.execute(
|
||
'UPDATE products SET stock_quantity = stock_quantity - ? WHERE id = ?',
|
||
[item.quantity, item.productId],
|
||
);
|
||
if (!invoice.isDraft) {
|
||
await txn.execute('UPDATE products SET is_locked = 1 WHERE id = ?', [item.productId]);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 顧客をロック
|
||
if (!invoice.isDraft) {
|
||
await txn.execute('UPDATE customers SET is_locked = 1 WHERE id = ?', [invoice.customer.id]);
|
||
}
|
||
});
|
||
|
||
await _logRepo.logAction(
|
||
action: "SAVE_INVOICE",
|
||
targetType: "INVOICE",
|
||
targetId: invoice.id,
|
||
details: "種別: ${invoice.documentTypeName}, 取引先: ${invoice.customerNameForDisplay}, 合計: ￥${invoice.totalAmount}",
|
||
);
|
||
}
|
||
|
||
Future<void> updateInvoice(Invoice invoice) async {
|
||
await saveInvoice(invoice);
|
||
}
|
||
|
||
Future<List<Invoice>> getAllInvoices(List<Customer> customers) async {
|
||
final db = await _dbHelper.database;
|
||
List<Map<String, dynamic>> invoiceMaps = await db.query('invoices', orderBy: 'date DESC');
|
||
|
||
// サンプル自動投入（伝票が0件なら）
|
||
if (invoiceMaps.isEmpty && customers.isNotEmpty) {
|
||
await _generateSampleInvoices(customers.take(3).toList());
|
||
invoiceMaps = await db.query('invoices', orderBy: 'date DESC');
|
||
}
|
||
|
||
List<Invoice> invoices = [];
|
||
for (var iMap in invoiceMaps) {
|
||
final customer = customers.firstWhere(
|
||
(c) => c.id == iMap['customer_id'],
|
||
orElse: () => Customer(id: iMap['customer_id'], displayName: "不明", formalName: "不明"),
|
||
);
|
||
|
||
final List<Map<String, dynamic>> itemMaps = await db.query(
|
||
'invoice_items',
|
||
where: 'invoice_id = ?',
|
||
whereArgs: [iMap['id']],
|
||
);
|
||
|
||
final items = List.generate(itemMaps.length, (i) => InvoiceItem.fromMap(itemMaps[i]));
|
||
|
||
// document_typeのパース
|
||
DocumentType docType = DocumentType.invoice;
|
||
if (iMap['document_type'] != null) {
|
||
try {
|
||
docType = DocumentType.values.firstWhere((e) => e.name == iMap['document_type']);
|
||
} catch (_) {}
|
||
}
|
||
|
||
invoices.add(Invoice(
|
||
id: iMap['id'],
|
||
customer: customer,
|
||
date: DateTime.parse(iMap['date']),
|
||
items: items,
|
||
notes: iMap['notes'],
|
||
filePath: iMap['file_path'],
|
||
taxRate: iMap['tax_rate'] ?? 0.10,
|
||
documentType: docType,
|
||
customerFormalNameSnapshot: iMap['customer_formal_name'],
|
||
odooId: iMap['odoo_id'],
|
||
isSynced: iMap['is_synced'] == 1,
|
||
updatedAt: DateTime.parse(iMap['updated_at']),
|
||
latitude: iMap['latitude'],
|
||
longitude: iMap['longitude'],
|
||
terminalId: iMap['terminal_id'] ?? "T1",
|
||
isDraft: (iMap['is_draft'] ?? 0) == 1,
|
||
subject: iMap['subject'],
|
||
isLocked: (iMap['is_locked'] ?? 0) == 1,
|
||
contactVersionId: iMap['contact_version_id'],
|
||
contactEmailSnapshot: iMap['contact_email_snapshot'],
|
||
contactTelSnapshot: iMap['contact_tel_snapshot'],
|
||
contactAddressSnapshot: iMap['contact_address_snapshot'],
|
||
companySnapshot: iMap['company_snapshot'],
|
||
companySealHash: iMap['company_seal_hash'],
|
||
metaJson: iMap['meta_json'],
|
||
metaHash: iMap['meta_hash'],
|
||
previousChainHash: iMap['previous_chain_hash'],
|
||
chainHash: iMap['chain_hash'],
|
||
chainStatus: iMap['chain_status'] ?? 'pending',
|
||
));
|
||
}
|
||
return invoices;
|
||
}
|
||
|
||
Future<void> _generateSampleInvoices(List<Customer> customers) async {
|
||
if (customers.isEmpty) return;
|
||
final now = DateTime.now();
|
||
final items = [
|
||
InvoiceItem(description: "商品A", quantity: 2, unitPrice: 1200),
|
||
InvoiceItem(description: "商品B", quantity: 1, unitPrice: 3000),
|
||
];
|
||
final List<Invoice> samples = List.generate(
|
||
3,
|
||
(i) => Invoice(
|
||
customer: customers[i % customers.length],
|
||
date: now.subtract(Duration(days: i * 3)),
|
||
items: items,
|
||
isDraft: i == 0, // 1件だけ下書き
|
||
subject: "サンプル案件${i + 1}",
|
||
),
|
||
);
|
||
|
||
for (final inv in samples) {
|
||
await saveInvoice(inv);
|
||
}
|
||
}
|
||
|
||
Future<void> deleteInvoice(String id) async {
|
||
final db = await _dbHelper.database;
|
||
await db.transaction((txn) async {
|
||
// 在庫の復元
|
||
final List<Map<String, dynamic>> items = await txn.query(
|
||
'invoice_items',
|
||
where: 'invoice_id = ?',
|
||
whereArgs: [id],
|
||
);
|
||
|
||
for (var item in items) {
|
||
if (item['product_id'] != null) {
|
||
await txn.execute(
|
||
'UPDATE products SET stock_quantity = stock_quantity + ? WHERE id = ?',
|
||
[item['quantity'], item['product_id']],
|
||
);
|
||
}
|
||
}
|
||
|
||
// PDFパスの取得（削除用）
|
||
final List<Map<String, dynamic>> maps = await txn.query(
|
||
'invoices',
|
||
columns: ['file_path'],
|
||
where: 'id = ?',
|
||
whereArgs: [id],
|
||
);
|
||
|
||
if (maps.isNotEmpty && maps.first['file_path'] != null) {
|
||
final file = File(maps.first['file_path']);
|
||
if (await file.exists()) {
|
||
await file.delete();
|
||
}
|
||
}
|
||
|
||
await txn.delete(
|
||
'invoice_items',
|
||
where: 'invoice_id = ?',
|
||
whereArgs: [id],
|
||
);
|
||
await txn.delete(
|
||
'invoices',
|
||
where: 'id = ?',
|
||
whereArgs: [id],
|
||
);
|
||
});
|
||
}
|
||
|
||
Future<int> cleanupOrphanedPdfs() async {
|
||
try {
|
||
final directory = await getExternalStorageDirectory();
|
||
if (directory == null) return 0;
|
||
|
||
final files = directory.listSync().whereType<File>().toList();
|
||
final db = await _dbHelper.database;
|
||
final List<Map<String, dynamic>> results = await db.query('invoices', columns: ['file_path']);
|
||
final activePaths = results.map((r) => r['file_path'] as String?).where((p) => p != null).toSet();
|
||
|
||
int count = 0;
|
||
for (var file in files) {
|
||
if (file.path.endsWith('.pdf') && !activePaths.contains(file.path)) {
|
||
await file.delete();
|
||
count++;
|
||
}
|
||
}
|
||
return count;
|
||
} catch (e) {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/// meta_json と meta_hash の整合性を検証する（trueなら一致）。
|
||
bool verifyInvoiceMeta(Invoice invoice) {
|
||
final metaJson = invoice.metaJson ?? invoice.metaJsonValue;
|
||
final expected = sha256.convert(utf8.encode(metaJson)).toString();
|
||
final stored = invoice.metaHash ?? expected;
|
||
return expected == stored;
|
||
}
|
||
|
||
/// IDを指定してDBから取得し、メタデータ整合性を検証する。
|
||
Future<bool> verifyInvoiceMetaById(String id, List<Customer> customers) async {
|
||
final invoices = await getAllInvoices(customers);
|
||
final target = invoices.firstWhere((i) => i.id == id, orElse: () => throw Exception('invoice not found'));
|
||
return verifyInvoiceMeta(target);
|
||
}
|
||
|
||
Future<HashChainVerificationResult> verifyHashChain() async {
|
||
final db = await _dbHelper.database;
|
||
final now = DateTime.now();
|
||
return await db.transaction((txn) async {
|
||
final rows = await txn.query(
|
||
'invoices',
|
||
columns: [
|
||
'id',
|
||
'updated_at',
|
||
'content_hash',
|
||
'previous_chain_hash',
|
||
'chain_hash',
|
||
'document_type',
|
||
'terminal_id',
|
||
'date',
|
||
],
|
||
where: 'COALESCE(is_draft, 0) = 0',
|
||
orderBy: 'updated_at ASC, id ASC',
|
||
);
|
||
|
||
String? expectedPreviousHash;
|
||
final breaks = <HashChainBreak>[];
|
||
|
||
for (final row in rows) {
|
||
final invoiceId = row['id'] as String;
|
||
final invoiceNumber = _buildInvoiceNumberFromRow(row);
|
||
final updatedAtStr = row['updated_at'] as String;
|
||
final updatedAt = DateTime.parse(updatedAtStr);
|
||
final contentHash = row['content_hash'] as String? ?? '';
|
||
final actualPrev = row['previous_chain_hash'] as String?;
|
||
final actualHash = row['chain_hash'] as String?;
|
||
final expectedHash = _computeChainHash(expectedPreviousHash, contentHash, updatedAt, invoiceId);
|
||
|
||
bool broken = false;
|
||
if ((expectedPreviousHash ?? '') != (actualPrev ?? '')) {
|
||
final info = HashChainBreak(
|
||
invoiceId: invoiceId,
|
||
invoiceNumber: invoiceNumber,
|
||
issue: 'previous_hash_mismatch',
|
||
expectedHash: expectedHash,
|
||
actualHash: actualHash,
|
||
expectedPreviousHash: expectedPreviousHash,
|
||
actualPreviousHash: actualPrev,
|
||
);
|
||
breaks.add(info);
|
||
await _logChainBreak(info);
|
||
broken = true;
|
||
}
|
||
|
||
if (actualHash == null || actualHash != expectedHash) {
|
||
final info = HashChainBreak(
|
||
invoiceId: invoiceId,
|
||
invoiceNumber: invoiceNumber,
|
||
issue: actualHash == null ? 'hash_missing' : 'hash_mismatch',
|
||
expectedHash: expectedHash,
|
||
actualHash: actualHash,
|
||
expectedPreviousHash: expectedPreviousHash,
|
||
actualPreviousHash: actualPrev,
|
||
);
|
||
breaks.add(info);
|
||
await _logChainBreak(info);
|
||
broken = true;
|
||
}
|
||
|
||
await txn.update(
|
||
'invoices',
|
||
{'chain_status': broken ? 'broken' : 'healthy'},
|
||
where: 'id = ?',
|
||
whereArgs: [invoiceId],
|
||
);
|
||
|
||
expectedPreviousHash = expectedHash;
|
||
}
|
||
|
||
await _logRepo.logAction(
|
||
action: 'HASH_CHAIN_VERIFY',
|
||
targetType: 'INVOICE',
|
||
details: jsonEncode({
|
||
'checkedCount': rows.length,
|
||
'breakCount': breaks.length,
|
||
'verifiedAt': now.toIso8601String(),
|
||
}),
|
||
);
|
||
|
||
return HashChainVerificationResult(
|
||
isHealthy: breaks.isEmpty,
|
||
checkedCount: rows.length,
|
||
verifiedAt: now,
|
||
breaks: breaks,
|
||
);
|
||
});
|
||
}
|
||
|
||
Future<Map<String, Object?>?> _fetchLatestChainEntry(DatabaseExecutor txn) async {
|
||
final rows = await txn.query(
|
||
'invoices',
|
||
columns: ['chain_hash'],
|
||
where: 'COALESCE(is_draft, 0) = 0 AND chain_hash IS NOT NULL',
|
||
orderBy: 'updated_at DESC, id DESC',
|
||
limit: 1,
|
||
);
|
||
if (rows.isEmpty) return null;
|
||
return rows.first;
|
||
}
|
||
|
||
String _computeChainHash(String? previousHash, String contentHash, DateTime updatedAt, String id) {
|
||
final payload = '${previousHash ?? ''}|$contentHash|${updatedAt.toIso8601String()}|$id';
|
||
return sha256.convert(utf8.encode(payload)).toString();
|
||
}
|
||
|
||
Future<void> _logChainBreak(HashChainBreak info) async {
|
||
await _logRepo.logAction(
|
||
action: 'HASH_CHAIN_BREAK',
|
||
targetType: 'INVOICE',
|
||
targetId: info.invoiceId,
|
||
details: jsonEncode({
|
||
'issue': info.issue,
|
||
'invoiceNumber': info.invoiceNumber,
|
||
'expectedHash': info.expectedHash,
|
||
'actualHash': info.actualHash,
|
||
'expectedPreviousHash': info.expectedPreviousHash,
|
||
'actualPreviousHash': info.actualPreviousHash,
|
||
}),
|
||
);
|
||
}
|
||
|
||
String _buildInvoiceNumberFromRow(Map<String, Object?> row) {
|
||
final docTypeName = row['document_type'] as String? ?? DocumentType.invoice.name;
|
||
DocumentType docType;
|
||
try {
|
||
docType = DocumentType.values.firstWhere((e) => e.name == docTypeName);
|
||
} catch (_) {
|
||
docType = DocumentType.invoice;
|
||
}
|
||
final prefix = _documentPrefix(docType);
|
||
final terminalId = row['terminal_id'] as String? ?? 'T1';
|
||
final dateStr = row['date'] as String? ?? row['updated_at'] as String;
|
||
final date = DateTime.tryParse(dateStr) ?? DateTime.now();
|
||
final id = row['id'] as String;
|
||
final suffix = id.length >= 4 ? id.substring(id.length - 4) : id;
|
||
final formatter = DateFormat('yyyyMMdd');
|
||
return '$prefix-$terminalId-${formatter.format(date)}-$suffix';
|
||
}
|
||
|
||
String _documentPrefix(DocumentType type) {
|
||
switch (type) {
|
||
case DocumentType.estimation:
|
||
return 'EST';
|
||
case DocumentType.delivery:
|
||
return 'DEL';
|
||
case DocumentType.invoice:
|
||
return 'INV';
|
||
case DocumentType.receipt:
|
||
return 'REC';
|
||
}
|
||
}
|
||
|
||
Future<SalesSummary> fetchSalesSummary({
|
||
required int year,
|
||
DocumentType? documentType,
|
||
bool includeDrafts = false,
|
||
int topCustomerLimit = 5,
|
||
}) async {
|
||
final db = await _dbHelper.database;
|
||
final baseArgs = <Object?>[year.toString()];
|
||
final whereBuffer = StringBuffer("strftime('%Y', date) = ?");
|
||
if (documentType != null) {
|
||
whereBuffer.write(" AND document_type = ?");
|
||
baseArgs.add(documentType.name);
|
||
}
|
||
if (!includeDrafts) {
|
||
whereBuffer.write(" AND COALESCE(is_draft, 0) = 0");
|
||
}
|
||
final whereClause = whereBuffer.toString();
|
||
|
||
final monthlyRows = await db.rawQuery(
|
||
'''
|
||
SELECT CAST(strftime('%m', date) AS INTEGER) as month, SUM(total_amount) as total
|
||
FROM invoices
|
||
WHERE $whereClause
|
||
GROUP BY month
|
||
ORDER BY month ASC
|
||
'''.
|
||
trim(),
|
||
List<Object?>.from(baseArgs),
|
||
);
|
||
|
||
final monthlyTotals = <int, int>{};
|
||
for (final row in monthlyRows) {
|
||
if (row['month'] == null || row['total'] == null) continue;
|
||
monthlyTotals[(row['month'] as num).toInt()] = (row['total'] as num).toInt();
|
||
}
|
||
|
||
final yearlyTotal = monthlyTotals.values.fold<int>(0, (sum, value) => sum + value);
|
||
|
||
final customerRows = await db.rawQuery(
|
||
'''
|
||
SELECT COALESCE(customer_formal_name, customer_id) as customer_name, SUM(total_amount) as total
|
||
FROM invoices
|
||
WHERE $whereClause
|
||
GROUP BY customer_name
|
||
ORDER BY total DESC
|
||
LIMIT ?
|
||
'''.
|
||
trim(),
|
||
[...baseArgs, topCustomerLimit],
|
||
);
|
||
|
||
final customerStats = customerRows
|
||
.where((row) => row['customer_name'] != null && row['total'] != null)
|
||
.map(
|
||
(row) => SalesCustomerStat(
|
||
customerName: row['customer_name'] as String,
|
||
totalAmount: (row['total'] as num).toInt(),
|
||
),
|
||
)
|
||
.toList();
|
||
|
||
return SalesSummary(
|
||
year: year,
|
||
documentType: documentType,
|
||
monthlyTotals: monthlyTotals,
|
||
yearlyTotal: yearlyTotal,
|
||
customerStats: customerStats,
|
||
);
|
||
}
|
||
|
||
Future<Map<String, int>> getMonthlySales(int year) async {
|
||
final summary = await fetchSalesSummary(year: year);
|
||
return summary.monthlyTotals.map((key, value) => MapEntry(key.toString().padLeft(2, '0'), value));
|
||
}
|
||
|
||
Future<int> getYearlyTotal(int year) async {
|
||
final summary = await fetchSalesSummary(year: year);
|
||
return summary.yearlyTotal;
|
||
}
|
||
}
|