Hoan thien core finance v2 - Calculation Pipeline, Form Templates

2026-04-28 03:57:18 +00:00
parent 002c9a8b99
commit 49aa20a634
24 changed files with 1043 additions and 875 deletions
--- a/app/Services/Calculation/CalculationPipeline.php
+++ b/app/Services/Calculation/CalculationPipeline.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Services\Calculation;
+
+class CalculationPipeline
+{
+    protected array $steps = [];
+
+    public function addStep(CalculationStep $step): static
+    {
+        $this->steps[] = $step;
+        return $this;
+    }
+
+    public function execute(array $initialData): CalculationResult
+    {
+        $data = $initialData;
+        $result = new CalculationResult();
+
+        foreach ($this->steps as $step) {
+            $stepResult = $step->execute($data);
+            $result->addStep($stepResult);
+            $data[$step->outputKey()] = $stepResult['rounded_value'];
+        }
+
+        return $result;
+    }
+
+    public function getSteps(): array
+    {
+        return $this->steps;
+    }
+}
--- a/app/Services/Calculation/CalculationResult.php
+++ b/app/Services/Calculation/CalculationResult.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Services\Calculation;
+
+class CalculationResult
+{
+    protected array $steps = [];
+    protected array $values = [];
+
+    public function addStep(array $stepResult): void
+    {
+        $this->steps[] = $stepResult;
+        $this->values[$stepResult['output_key']] = $stepResult['rounded_value'];
+    }
+
+    public function get(string $key): ?int
+    {
+        return $this->values[$key] ?? null;
+    }
+
+    public function getSteps(): array
+    {
+        return $this->steps;
+    }
+
+    public function getValues(): array
+    {
+        return $this->values;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'steps' => $this->steps,
+            'final_values' => $this->values,
+        ];
+    }
+
+    public function toPriceSheet(): array
+    {
+        $sheet = [];
+        foreach ($this->steps as $step) {
+            $sheet[] = [
+                'description' => $step['name'],
+                'value' => $step['rounded_value'],
+                'is_overridden' => $step['is_overridden'],
+            ];
+        }
+        return $sheet;
+    }
+}
--- a/app/Services/Calculation/CalculationStep.php
+++ b/app/Services/Calculation/CalculationStep.php
@@ -0,0 +1,83 @@
+<?php
+
+namespace App\Services\Calculation;
+
+class CalculationStep
+{
+    protected string $name;
+    protected string $outputKey;
+    protected \Closure $formula;
+    protected RoundingRule $roundingRule;
+    protected ?int $overrideValue = null;
+    protected bool $isOverridden = false;
+    protected array $dependencies = [];
+
+    public function __construct(
+        string $name,
+        string $outputKey,
+        \Closure $formula,
+        RoundingRule $roundingRule = RoundingRule::UNIT,
+        array $dependencies = []
+    ) {
+        $this->name = $name;
+        $this->outputKey = $outputKey;
+        $this->formula = $formula;
+        $this->roundingRule = $roundingRule;
+        $this->dependencies = $dependencies;
+    }
+
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    public function outputKey(): string
+    {
+        return $this->outputKey;
+    }
+
+    public function dependencies(): array
+    {
+        return $this->dependencies;
+    }
+
+    public function override(int $value): static
+    {
+        $this->overrideValue = $value;
+        $this->isOverridden = true;
+        return $this;
+    }
+
+    public function isOverridden(): bool
+    {
+        return $this->isOverridden;
+    }
+
+    public function execute(array $data): array
+    {
+        if ($this->isOverridden) {
+            return [
+                'name' => $this->name,
+                'output_key' => $this->outputKey,
+                'formula_raw' => null,
+                'calculated_value' => null,
+                'rounded_value' => $this->overrideValue,
+                'is_overridden' => true,
+                'dependencies' => $this->dependencies,
+            ];
+        }
+
+        $rawValue = call_user_func($this->formula, $data);
+        $roundedValue = $this->roundingRule->apply($rawValue);
+
+        return [
+            'name' => $this->name,
+            'output_key' => $this->outputKey,
+            'formula_raw' => $rawValue,
+            'calculated_value' => $rawValue,
+            'rounded_value' => $roundedValue,
+            'is_overridden' => false,
+            'dependencies' => $this->dependencies,
+        ];
+    }
+}
--- a/app/Services/Calculation/PriceCalculationService.php
+++ b/app/Services/Calculation/PriceCalculationService.php
@@ -0,0 +1,110 @@
+<?php
+
+namespace App\Services\Calculation;
+
+use App\Models\Contract;
+
+class PriceCalculationService
+{
+    public static function forContract(Contract $contract): CalculationPipeline
+    {
+        $pipeline = new CalculationPipeline();
+
+        // Bước 1: Tổng giá trị trước chiết khấu
+        $pipeline->addStep(new CalculationStep(
+            name: 'Giá trị QSDĐ',
+            outputKey: 'land_value',
+            formula: fn ($data) => (float) ($data['land_value'] ?? 0),
+            roundingRule: RoundingRule::UNIT,
+            dependencies: []
+        ));
+
+        $pipeline->addStep(new CalculationStep(
+            name: 'Giá trị Móng',
+            outputKey: 'foundation_value',
+            formula: fn ($data) => (float) ($data['foundation_value'] ?? 0),
+            roundingRule: RoundingRule::UNIT,
+            dependencies: []
+        ));
+
+        $pipeline->addStep(new CalculationStep(
+            name: 'Tổng giá trị trước chiết khấu',
+            outputKey: 'subtotal',
+            formula: fn ($data) => $data['land_value'] + $data['foundation_value'],
+            roundingRule: RoundingRule::UNIT,
+            dependencies: ['land_value', 'foundation_value']
+        ));
+
+        // Bước 2: Chiết khấu
+        $pipeline->addStep(new CalculationStep(
+            name: 'Chiết khấu',
+            outputKey: 'discount_amount',
+            formula: function ($data) {
+                $details = $data['discount_details'] ?? [];
+                if (!empty($details['total_amount'])) {
+                    return (float) $details['total_amount'];
+                }
+                if (!empty($details['total_percentage'])) {
+                    return $data['subtotal'] * ((float) $details['total_percentage'] / 100);
+                }
+                return 0;
+            },
+            roundingRule: RoundingRule::UNIT,
+            dependencies: ['subtotal', 'discount_details']
+        ));
+
+        // Bước 3: Sau chiết khấu
+        $pipeline->addStep(new CalculationStep(
+            name: 'Giá trị sau chiết khấu',
+            outputKey: 'net_value',
+            formula: fn ($data) => $data['subtotal'] - $data['discount_amount'],
+            roundingRule: RoundingRule::UNIT,
+            dependencies: ['subtotal', 'discount_amount']
+        ));
+
+        // Bước 4: VAT (nếu có)
+        $pipeline->addStep(new CalculationStep(
+            name: 'Thuế VAT',
+            outputKey: 'vat_amount',
+            formula: function ($data) {
+                $vatRate = (float) ($data['vat_rate'] ?? 0);
+                return $data['net_value'] * ($vatRate / 100);
+            },
+            roundingRule: RoundingRule::UNIT,
+            dependencies: ['net_value', 'vat_rate']
+        ));
+
+        // Bước 5: Tổng thanh toán
+        $pipeline->addStep(new CalculationStep(
+            name: 'Tổng thanh toán',
+            outputKey: 'total_payment',
+            formula: fn ($data) => $data['net_value'] + $data['vat_amount'],
+            roundingRule: RoundingRule::UNIT,
+            dependencies: ['net_value', 'vat_amount']
+        ));
+
+        return $pipeline;
+    }
+
+    public static function calculateForContract(Contract $contract, array $overrides = []): CalculationResult
+    {
+        $pipeline = self::forContract($contract);
+        $data = [
+            'land_value' => (float) $contract->land_value,
+            'foundation_value' => (float) $contract->foundation_value,
+            'discount_details' => $contract->discount_details ?? [],
+            'vat_rate' => (float) ($contract->metadata['vat_rate'] ?? 0),
+        ];
+
+        // Áp dụng ghi đè nếu có
+        if (!empty($overrides)) {
+            foreach ($pipeline->getSteps() as $step) {
+                if (isset($overrides[$step->outputKey()])) {
+                    $step->override((int) $overrides[$step->outputKey()]);
+                }
+            }
+        }
+
+        return $pipeline->execute($data);
+    }
+}
--- a/app/Services/Calculation/RoundingRule.php
+++ b/app/Services/Calculation/RoundingRule.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services\Calculation;
+
+enum RoundingRule: string
+{
+    case NONE = 'none';              // Không làm tròn
+    case UNIT = 'unit';              // Làm tròn đến đồng (số nguyên)
+    case THOUSAND = 'thousand';      // Làm tròn đến nghìn
+    case MILLION = 'million';        // Làm tròn đến triệu
+
+    public function apply(float $value): int
+    {
+        return match ($this) {
+            self::NONE => (int) $value,
+            self::UNIT => (int) round($value),
+            self::THOUSAND => (int) (round($value / 1000) * 1000),
+            self::MILLION => (int) (round($value / 1000000) * 1000000),
+        };
+    }
+}
--- a/app/Services/Forms/MailMergeService.php
+++ b/app/Services/Forms/MailMergeService.php
@@ -0,0 +1,169 @@
+<?php
+
+namespace App\Services\Forms;
+
+use App\Models\FormTemplate;
+use App\Models\FormPrintLog;
+
+class MailMergeService
+{
+    /**
+     * Evaluate all fields for a given record and return values array.
+     */
+    public static function evaluateFields(FormTemplate $template, Model $record): array
+    {
+        $values = [];
+
+        foreach ($template->fields as $field) {
+            $values[$field->code] = self::evaluateSingleField($field, $record, $values);
+        }
+
+        return $values;
+    }
+
+    protected static function evaluateSingleField($field, Model $record, array $evaluatedValues): mixed
+    {
+        $config = $field->source_config ?? [];
+
+        return match ($field->source_type) {
+            'db_column' => self::getDbColumnValue($record, $config['column'] ?? null),
+            'db_relation' => self::getRelationValue($record, $config),
+            'formula' => self::evaluateFormula($config['expression'] ?? '', $evaluatedValues),
+            'input' => $config['default'] ?? '',
+            'static' => $config['value'] ?? '',
+            default => '',
+        };
+    }
+
+    protected static function getDbColumnValue(Model $record, ?string $column): mixed
+    {
+        if (! $column) return '';
+        return $record->{$column} ?? '';
+    }
+
+    protected static function getRelationValue(Model $record, array $config): mixed
+    {
+        $relation = $config['relation'] ?? null;
+        $column = $config['column'] ?? null;
+        $index = $config['index'] ?? null;
+
+        if (! $relation || ! $column) return '';
+
+        $related = $record->{$relation};
+
+        if (is_null($related)) return '';
+
+        if ($related instanceof \Illuminate\Database\Eloquent\Collection) {
+            if ($index !== null) {
+                $item = $related->skip($index)->first();
+                return $item?->{$column} ?? '';
+            }
+            return $related->pluck($column)->implode(', ');
+        }
+
+        return $related->{$column} ?? '';
+    }
+
+    protected static function evaluateFormula(string $expression, array $values): float
+    {
+        if (empty($expression)) return 0;
+
+        // Thay thế tên biến bằng giá trị
+        $evalExpression = $expression;
+        foreach ($values as $key => $value) {
+            if (is_numeric($value)) {
+                $evalExpression = str_replace($key, (float) $value, $evalExpression);
+            }
+        }
+
+        // Chỉ cho phép số và các phép toán cơ bản
+        $evalExpression = preg_replace('/[^0-9.\+\-\*\/\(\)\s]/', '', $evalExpression);
+
+        if (empty($evalExpression)) return 0;
+
+        try {
+            // Eval an toàn với chỉ phép toán
+            $result = self::safeEval($evalExpression);
+            return (float) $result;
+        } catch (\Throwable $e) {
+            return 0;
+        }
+    }
+
+    protected static function safeEval(string $expression): float
+    {
+        // Loại bỏ các hàm nguy hiểm, chỉ giữ phép toán
+        $expression = preg_replace('/[^0-9.\+\-\*\/\(\)\s]/', '', $expression);
+
+        if (empty($expression) || preg_match('/[a-zA-Z]/', $expression)) {
+            throw new \InvalidArgumentException('Invalid expression');
+        }
+
+        // Dùng bc math nếu có, hoặc eval đơn giản
+        return (float) eval('return ' . $expression . ';');
+    }
+
+    /**
+     * Format value theo kiểu field.
+     */
+    public static function formatValue(mixed $value, string $format, int $decimals = 0): string
+    {
+        return match ($format) {
+            'number' => number_format((float) $value, $decimals, ',', '.'),
+            'currency' => number_format((float) $value, 0, ',', '.') . ' VNĐ',
+            'percent' => number_format((float) $value, $decimals, ',', '.') . '%',
+            'date' => $value ? \Carbon\Carbon::parse($value)->format('d/m/Y') : '',
+            default => (string) $value,
+        };
+    }
+
+    /**
+     * Render template with evaluated values.
+     */
+    public static function render(FormTemplate $template, Model $record): array
+    {
+        $rawValues = self::evaluateFields($template, $record);
+
+        $formattedValues = [];
+        foreach ($template->fields as $field) {
+            $code = $field->code;
+            $rawValue = $rawValues[$code] ?? '';
+            $formattedValues[$code] = self::formatValue(
+                $rawValue,
+                $field->format,
+                $field->decimal_places
+            );
+        }
+
+        $html = $template->html_template;
+        foreach ($formattedValues as $code => $value) {
+            $html = str_replace('{{' . $code . '}}', (string) $value, $html);
+        }
+
+        return [
+            'html' => $html,
+            'raw_values' => $rawValues,
+            'formatted_values' => $formattedValues,
+        ];
+    }
+
+    /**
+     * Save print log with snapshot.
+     */
+    public static function savePrintLog(FormTemplate $template, Model $record, array $renderResult, int $userId): FormPrintLog
+    {
+        return FormPrintLog::create([
+            'template_id' => $template->id,
+            'target_model' => get_class($record),
+            'target_id' => $record->id,
+            'target_number' => $record->contract_number ?? $record->code ?? null,
+            'snapshot_data' => [
+                'raw_values' => $renderResult['raw_values'],
+                'formatted_values' => $renderResult['formatted_values'],
+            ],
+            'rendered_html' => $renderResult['html'],
+            'printed_by' => $userId,
+            'printed_at' => now(),
+        ]);
+    }
+}