doc.vvsw.de

Eine ältere Version des Dokuments wurde geladen! Beim Speichern wird eine neue Version des Dokuments mit diesem Inhalt erstellt.

Vorschlag: Umstrukturierung der Käufererstellung nach 3-Schichten-Architektur
Analyse der aktuellen Implementierung
Aktuelle Struktur (Buyer::Create())
Die aktuelle Buyer::Create() Funktion enthält alle Schichten vermischt:

Validierung (ValidateData, ValidateVaucher, CheckDuplicate, CheckLager, CheckCountry)
Geschäftslogik (setAgentByEmail, Generierung von Passwort/Kundennummer/Username, Bestimmung von frominternet)
Datenbankzugriffe (InsertBuyer, SaveAdresses, SaveBank, direkte SQL-Queries)
Cache-Operationen (CacheBuyers, CacheAddress)
Externe Integrationen (E-Mail-Versand, CMP-Export, Letter Package)
Orchestrierung (implizit durch die Reihenfolge der Aufrufe)
Vorschlag: Neue Struktur
Übersicht der Schichten
API (CustomerController)
  ↓
Orchestrierung (BuyerCreationOrchestration)
  ↓
  ├─→ Business-Funktionen (Fachfunktionen)
  │   ├─→ ValidateBuyerDataFunction
  │   ├─→ DetermineSponsorFunction
  │   ├─→ GenerateBuyerIdentifiersFunction
  │   ├─→ ValidateAddressesFunction
  │   ├─→ DetermineRegistrationSourceFunction
  │   └─→ ValidateVoucherFunction
  ↓
Zwischenschicht (Repositories)
  ├─→ BuyerRepository
  ├─→ AddressRepository
  ├─→ BankRepository
  ├─→ UserRepository
  ├─→ SponsorRepository
  ├─→ VoucherRepository
  └─→ InterestingRepository
  ↓
Framework (Yii2)
Detaillierte Aufteilung
1. API Layer
Datei: backend/modules/api/controllers/CustomerController.php

Verantwortlichkeiten:

Empfang von HTTP-Requests
Validierung des Request-Formats
Aufruf der Orchestrierung
Formatierung der Response
Fehlerbehandlung auf API-Ebene
Code-Struktur:

class CustomerController extends Controller
{
    public function actionCreate($request)
    {
        try {
            // 1. Request-Validierung (Format, nicht Inhalt!)
            $this->validateRequestFormat($request);
            
            // 2. Aufruf Orchestrierung
            $orchestration = Yii::$container->get(BuyerCreationOrchestration::class);
            $result = $orchestration->createBuyer($request);
            
            // 3. Response formatieren
            return $this->formatResponse($result);
            
        } catch (ValidationException $e) {
            return $this->formatErrorResponse($e);
        } catch (\Exception $e) {
            return $this->formatErrorResponse($e);
        }
    }
}
Was NICHT hier:

❌ Geschäftslogik
❌ Validierung von Geschäftsdaten
❌ Entscheidungen über Prozessablauf
2. Orchestrierung (BuyerCreationOrchestration)
Datei: backend/modules/core/orchestration/BuyerCreationOrchestration.php

Verantwortlichkeiten:

Koordination des gesamten Erstellungsprozesses
Aufruf der Business-Funktionen in richtiger Reihenfolge
Datenbeschaffung über Zwischenschicht
Zusammenführung der Ergebnisse
KEINE Geschäftsentscheidungen
Code-Struktur:

class BuyerCreationOrchestration
{
    private $buyerRepository;
    private $validateBuyerDataFunction;
    private $determineSponsorFunction;
    private $generateIdentifiersFunction;
    private $validateAddressesFunction;
    private $determineRegistrationSourceFunction;
    private $validateVoucherFunction;
    private $saveBuyerFunction;
    private $saveAddressesFunction;
    private $saveBankFunction;
    private $sendEmailFunction;
    private $cacheService;
    private $cmpService;
    
    public function createBuyer($request)
    {
        // 1. Daten aus Request extrahieren
        $buyerData = $this->extractBuyerData($request);
        
        // 2. Validierung der Eingabedaten
        $validationResult = $this->validateBuyerDataFunction->validate($buyerData);
        if (!$validationResult->isValid()) {
            return $this->createErrorResponse($validationResult);
        }
        
        // 3. Bestimmung des Sponsors (agentid)
        $sponsorData = $this->determineSponsorFunction->determine($buyerData);
        $buyerData->merge($sponsorData);
        
        // 4. Validierung Gutschein (wenn aktiviert)
        if ($this->isVoucherValidationEnabled()) {
            $voucherResult = $this->validateVoucherFunction->validate($buyerData);
            $buyerData->merge($voucherResult);
        }
        
        // 5. Prüfung auf Duplikate (wenn nicht Guest)
        if (!$buyerData->isGuest() && !$buyerData->skipDuplicateCheck()) {
            $duplicateCheck = $this->checkDuplicates($buyerData);
            if ($duplicateCheck->hasDuplicates()) {
                return $this->createDuplicateResponse($duplicateCheck);
            }
        }
        
        // 6. Automatische Erstellung aus Interessent (wenn aktiviert)
        if ($this->isAutoCreateFromInterestingEnabled() && $buyerData->hasEmail()) {
            $interestingData = $this->buyerRepository->findInterestingByEmail($buyerData->getEmail());
            if ($interestingData) {
                return $this->createFromInteresting($interestingData, $buyerData);
            }
        }
        
        // 7. Bestimmung der Registrierungsquelle (frominternet)
        $registrationSource = $this->determineRegistrationSourceFunction->determine($buyerData);
        $buyerData->setRegistrationSource($registrationSource);
        
        // 8. Generierung von Identifikatoren
        $identifiers = $this->generateIdentifiersFunction->generate($buyerData);
        $buyerData->merge($identifiers);
        
        // 9. Validierung von Adressen
        if ($buyerData->hasAddresses()) {
            $addressValidation = $this->validateAddressesFunction->validate($buyerData->getAddresses());
            if (!$addressValidation->isValid()) {
                return $this->createErrorResponse($addressValidation);
            }
        }
        
        // 10. Validierung Lager (wenn angegeben)
        if ($buyerData->hasWarehouse()) {
            $warehouseValidation = $this->validateWarehouse($buyerData);
            if (!$warehouseValidation->isValid()) {
                return $this->createErrorResponse($warehouseValidation);
            }
        }
        
        // 11. Speicherung des Käufers
        $savedBuyer = $this->saveBuyerFunction->save($buyerData);
        
        // 12. Speicherung der Adressen
        if ($buyerData->hasAddresses()) {
            $this->saveAddressesFunction->save($savedBuyer->getId(), $buyerData->getAddresses());
        }
        
        // 13. Speicherung der Bankdaten
        if ($buyerData->hasBankData()) {
            $this->saveBankFunction->save($savedBuyer->getId(), $buyerData->getBankData());
        }
        
        // 14. Erstellung des Benutzers (WboUser)
        $user = $this->createUser($savedBuyer, $buyerData);
        
        // 15. Zusätzliche Aktionen
        $this->performPostCreationActions($savedBuyer, $buyerData);
        
        // 16. Cache aktualisieren
        $this->cacheService->cacheBuyer($savedBuyer->getId());
        $this->cacheService->cacheAddresses($savedBuyer->getId());
        
        // 17. Response zusammenstellen
        return $this->createSuccessResponse($savedBuyer, $user);
    }
    
    private function checkDuplicates($buyerData)
    {
        // Aufruf über Repository
        return $this->buyerRepository->checkDuplicates($buyerData);
    }
    
    private function validateWarehouse($buyerData)
    {
        // Business-Funktion für Lager-Validierung
        return $this->validateWarehouseFunction->validate($buyerData);
    }
    
    private function createUser($buyer, $buyerData)
    {
        // Orchestrierung für User-Erstellung (kann auch eigene Orchestrierung haben)
        $userOrchestration = Yii::$container->get(UserCreationOrchestration::class);
        return $userOrchestration->createUser($buyer, $buyerData);
    }
    
    private function performPostCreationActions($buyer, $buyerData)
    {
        // E-Mail-Versand (wenn nicht Guest)
        if (!$buyerData->isGuest()) {
            $this->sendEmailFunction->sendBuyerRegistrationEmail($buyer);
        }
        
        // Letter Package
        $this->letterPackageService->checkAndAdd($buyer, $buyerData);
        
        // Starter zu VP konvertieren (wenn starterid vorhanden)
        if ($buyerData->hasStarterId()) {
            $this->convertStarterToVP($buyerData->getStarterId());
        }
        
        // CMP-Export (wenn aktiviert)
        if ($this->isCmpExportEnabled()) {
            $this->cmpService->addToQueue($buyer->getId(), 1);
        }
    }
}
Was NICHT hier:

❌ Geschäftslogik (z.B. "wenn agentid fehlt, dann...")
❌ Direkte Datenbankzugriffe
❌ SQL-Queries
❌ Validierungsregeln
3. Business-Funktionen (Fachfunktionen)
3.1. ValidateBuyerDataFunction
Datei: backend/modules/core/functions/ValidateBuyerDataFunction.php

Verantwortlichkeiten:

Validierung aller Käuferdaten nach Geschäftsregeln
Prüfung von Pflichtfeldern
Format-Validierung (E-Mail, IBAN, Steuernummer, etc.)
Rückgabe von Validierungsergebnissen
Code-Struktur:

class ValidateBuyerDataFunction
{
    private $emailValidator;
    private $ibanValidator;
    private $taxIdValidator;
    private $usernameValidator;
    
    public function validate(BuyerData $buyerData): ValidationResult
    {
        $result = new ValidationResult();
        
        // 1. E-Mail-Validierung
        if ($buyerData->hasEmail()) {
            if (!$this->emailValidator->isValid($buyerData->getEmail())) {
                $result->addError('email', 'Invalid email format');
            }
        } else {
            $result->addError('email', 'Email is required');
        }
        
        // 2. Username-Validierung (wenn angegeben)
        if ($buyerData->hasUsername()) {
            if (!$this->usernameValidator->isUnique($buyerData->getUsername())) {
                $result->addError('username', 'Username already exists');
            }
        }
        
        // 3. Steuernummer-Validierung (wenn angegeben)
        if ($buyerData->hasTaxId()) {
            if (!$this->taxIdValidator->isValid($buyerData->getTaxId())) {
                $result->addError('taxId', 'Invalid tax ID');
            }
        }
        
        // 4. IBAN-Validierung (wenn Bankdaten vorhanden)
        if ($buyerData->hasBankData()) {
            $ibanValidation = $this->ibanValidator->validate($buyerData->getBankData());
            if (!$ibanValidation->isValid()) {
                $result->mergeErrors($ibanValidation);
            }
        }
        
        // 5. PLZ-Validierung (wenn Adressen vorhanden)
        if ($buyerData->hasAddresses()) {
            $plzValidation = $this->validatePostalCodes($buyerData->getAddresses());
            if (!$plzValidation->isValid()) {
                $result->mergeErrors($plzValidation);
            }
        }
        
        return $result;
    }
    
    private function validatePostalCodes(array $addresses): ValidationResult
    {
        $result = new ValidationResult();
        foreach ($addresses as $address) {
            if (!$this->postalCodeValidator->isValid($address->getPostCode(), $address->getCountry())) {
                $result->addError('postCode', 'Invalid postal code for country');
            }
        }
        return $result;
    }
}
Was NICHT hier:

❌ Datenbankzugriffe (nur über Interfaces/Repositories)
❌ SQL-Queries
❌ Framework-spezifischer Code
3.2. DetermineSponsorFunction
Datei: backend/modules/core/functions/DetermineSponsorFunction.php

Verantwortlichkeiten:

Bestimmung des Sponsors (agentid) nach Geschäftsregeln
Automatische Bestimmung über E-Mail (wenn aktiviert)
Rückgabe des Sponsor-Ergebnisses
Code-Struktur:

class DetermineSponsorFunction
{
    private $sponsorRepository;
    private $buyerRepository;
    private $config;
    
    public function determine(BuyerData $buyerData): SponsorResult
    {
        $result = new SponsorResult();
        
        // 1. Wenn agentid bereits vorhanden → validieren
        if ($buyerData->hasAgentId()) {
            $sponsor = $this->sponsorRepository->findByAgentId($buyerData->getAgentId());
            if (!$sponsor || !$sponsor->isActive()) {
                throw new InvalidSponsorException('Sponsor not found or inactive');
            }
            $result->setAgentId($sponsor->getAgentId());
            $result->setAgentInternalId($sponsor->getInternalId());
            return $result;
        }
        
        // 2. Automatische Bestimmung über E-Mail (wenn aktiviert)
        if ($this->config->isAgentByEmailEnabled() && $buyerData->hasEmail()) {
            $sponsor = $this->determineByEmail($buyerData->getEmail());
            if ($sponsor) {
                $result->setAgentId($sponsor->getAgentId());
                $result->setAgentInternalId($sponsor->getInternalId());
                return $result;
            }
        }
        
        // 3. Fallback auf Master-VP (Geschäftsregel)
        $masterVP = $this->sponsorRepository->findMasterVP();
        $result->setAgentId($masterVP->getAgentId());
        $result->setAgentInternalId($masterVP->getInternalId());
        
        return $result;
    }
    
    private function determineByEmail(string $email): ?Sponsor
    {
        // Geschäftsregel: Suche nach Käufer mit dieser E-Mail
        $buyer = $this->buyerRepository->findByEmail($email);
        if (!$buyer) {
            return null;
        }
        
        // Geschäftsregel: Bestimme Sponsor des gefundenen Käufers
        $sponsor = $this->sponsorRepository->findByBuyerId($buyer->getId());
        
        // Geschäftsregel: Sortierung (neueste/älteste)
        if ($this->config->getAgentByEmailMode() === 'newest') {
            // Neueste zuerst
            return $sponsor;
        } else {
            // Älteste zuerst
            return $sponsor;
        }
    }
}
3.3. GenerateBuyerIdentifiersFunction
Datei: backend/modules/core/functions/GenerateBuyerIdentifiersFunction.php

Verantwortlichkeiten:

Generierung von Kundennummer (kundennr)
Generierung von Username
Generierung von Passwort (wenn nicht vorhanden)
Bestimmung von accounting-Nummer
Rückgabe aller generierten Identifikatoren
Code-Struktur:

class GenerateBuyerIdentifiersFunction
{
    private $buyerRepository;
    private $passwordGenerator;
    private $usernameGenerator;
    private $customerNumberGenerator;
    
    public function generate(BuyerData $buyerData): IdentifierResult
    {
        $result = new IdentifierResult();
        
        // 1. Kundennummer generieren
        $customerNumber = $this->generateCustomerNumber($buyerData);
        $result->setCustomerNumber($customerNumber);
        
        // 2. Username generieren
        $username = $this->generateUsername($buyerData, $customerNumber);
        $result->setUsername($username);
        
        // 3. Passwort generieren (wenn nicht vorhanden)
        if (!$buyerData->hasPassword()) {
            $password = $this->passwordGenerator->generate();
            $result->setPassword($password);
        } else {
            $result->setPassword($buyerData->getPassword());
        }
        
        // 4. Accounting-Nummer bestimmen
        $accounting = $this->determineAccountingNumber($buyerData, $customerNumber);
        $result->setAccounting($accounting);
        
        return $result;
    }
    
    private function generateCustomerNumber(BuyerData $buyerData): string
    {
        // Geschäftsregel 1: Wenn number angegeben → verwenden (nach Prüfung)
        if ($buyerData->hasNumber() && !$buyerData->hasImportNumber()) {
            // Prüfung auf Eindeutigkeit über Repository
            if ($this->buyerRepository->isCustomerNumberAvailable($buyerData->getNumber())) {
                return $buyerData->getNumber();
            }
            throw new CustomerNumberAlreadyExistsException();
        }
        
        // Geschäftsregel 2: Wenn mitarbeiternr vorhanden → verwenden
        if ($buyerData->hasMitarbeiternr()) {
            return $buyerData->getMitarbeiternr();
        }
        
        // Geschäftsregel 3: Automatische Generierung
        return $this->customerNumberGenerator->generate();
    }
    
    private function generateUsername(BuyerData $buyerData, string $customerNumber): string
    {
        // Geschäftsregel: Wenn username vorhanden → verwenden (bereits validiert)
        if ($buyerData->hasUsername()) {
            return $buyerData->getUsername();
        }
        
        // Geschäftsregel: Generierung basierend auf Kundennummer
        return $this->usernameGenerator->generateFromCustomerNumber($customerNumber);
    }
    
    private function determineAccountingNumber(BuyerData $buyerData, string $customerNumber): string
    {
        // Geschäftsregel 1: Wenn emplaccounting vorhanden → verwenden
        if ($buyerData->hasEmplAccounting()) {
            return $buyerData->getEmplAccounting();
        }
        
        // Geschäftsregel 2: Wenn accounting vorhanden → verwenden
        if ($buyerData->hasAccounting()) {
            return $buyerData->getAccounting();
        }
        
        // Geschäftsregel 3: Fallback auf Kundennummer
        return $customerNumber;
    }
}
3.4. ValidateAddressesFunction
Datei: backend/modules/core/functions/ValidateAddressesFunction.php

Verantwortlichkeiten:

Validierung aller Adressen
Prüfung auf Pflichtfelder
Validierung von Ländern
Prüfung auf Konsistenz
Code-Struktur:

class ValidateAddressesFunction
{
    private $countryRepository;
    private $postalCodeValidator;
    
    public function validate(array $addresses): ValidationResult
    {
        $result = new ValidationResult();
        
        foreach ($addresses as $index => $address) {
            // 1. Land-Validierung
            if (!$address->hasCountry()) {
                $result->addError("addresses[$index].country", 'Country is required');
                continue;
            }
            
            $country = $this->countryRepository->findByCode($address->getCountry());
            if (!$country) {
                $result->addError("addresses[$index].country", 'Invalid country code');
                continue;
            }
            
            // 2. PLZ-Validierung
            if ($address->hasPostCode()) {
                if (!$this->postalCodeValidator->isValid($address->getPostCode(), $country)) {
                    $result->addError("addresses[$index].postCode", 'Invalid postal code');
                }
            }
            
            // 3. Weitere Validierungen...
        }
        
        return $result;
    }
}
3.5. DetermineRegistrationSourceFunction
Datei: backend/modules/core/functions/DetermineRegistrationSourceFunction.php

Verantwortlichkeiten:

Bestimmung von frominternet basierend auf autonumbertype
Rückgabe der Registrierungsquelle
Code-Struktur:

class DetermineRegistrationSourceFunction
{
    public function determine(BuyerData $buyerData): RegistrationSource
    {
        // Geschäftsregel: Mapping von autonumbertype zu frominternet
        if ($buyerData->hasAutonumbertype()) {
            $type = $buyerData->getAutonumbertype();
            
            if ($type === 3) {
                return new RegistrationSource(107, 'Internet registration');
            }
            
            if ($type === 5) {
                return new RegistrationSource(111, 'Special registration');
            }
            
            // Standard für andere autonumbertype
            return new RegistrationSource(103, 'Internet registration with auto number');
        }
        
        // Standard-Registrierungsquelle
        return new RegistrationSource(102, 'Standard registration');
    }
}
3.6. ValidateVoucherFunction
Datei: backend/modules/core/functions/ValidateVoucherFunction.php

Verantwortlichkeiten:

Validierung von Gutschein-Code
Bestimmung des zugehörigen Sponsors
Rückgabe des Sponsor-Ergebnisses
Code-Struktur:

class ValidateVoucherFunction
{
    private $voucherRepository;
    private $sponsorRepository;
    
    public function validate(BuyerData $buyerData): VoucherResult
    {
        $result = new VoucherResult();
        
        // Wenn kein agentid vorhanden → kein Gutschein-Check
        if (!$buyerData->hasAgentId()) {
            return $result;
        }
        
        // Prüfung ob agentid ein Gutschein-Code ist
        $voucher = $this->voucherRepository->findByCode($buyerData->getAgentId());
        if (!$voucher) {
            // Kein Gutschein → agentid bleibt unverändert
            return $result;
        }
        
        // Geschäftsregel: Sponsor aus Gutschein bestimmen
        $sponsor = $this->sponsorRepository->findByInternalId($voucher->getForAgent());
        if (!$sponsor) {
            throw new InvalidVoucherException('Sponsor for voucher not found');
        }
        
        // Ergebnis: agentid ersetzen, Gutschein-Code speichern
        $result->setAgentId($sponsor->getAgentId());
        $result->setAgentInternalId($sponsor->getInternalId());
        $result->setVoucherCode($buyerData->getAgentId());
        
        return $result;
    }
}
4. Zwischenschicht (Repositories)
4.1. BuyerRepository
Datei: backend/modules/core/repositories/BuyerRepository.php

Verantwortlichkeiten:

Alle SQL-Queries für Käufer
CRUD-Operationen
Suche nach Käufern
Duplikat-Prüfung
Code-Struktur:

class BuyerRepository implements BuyerRepositoryInterface
{
    private $db;
    
    public function create(BuyerEntity $buyer): BuyerEntity
    {
        // SQL-Query hier
        $sql = "INSERT INTO tb_kundendaten (...) VALUES (...)";
        $this->db->createCommand($sql, [...])->execute();
        
        // Stored Procedure aufrufen
        $this->db->createCommand("CALL kd_adresse(?)", [$buyer->getInternekdnr()])->execute();
        
        return $buyer;
    }
    
    public function findById(int $id): ?BuyerEntity
    {
        $sql = "SELECT * FROM tb_kundendaten WHERE internekdnr = ?";
        $row = $this->db->createCommand($sql, [$id])->queryOne();
        
        if (!$row) {
            return null;
        }
        
        return $this->mapToEntity($row);
    }
    
    public function findByEmail(string $email): ?BuyerEntity
    {
        $sql = "SELECT * FROM tb_kundendaten WHERE kdemail = ?";
        $row = $this->db->createCommand($sql, [$email])->queryOne();
        
        if (!$row) {
            return null;
        }
        
        return $this->mapToEntity($row);
    }
    
    public function isCustomerNumberAvailable(string $customerNumber): bool
    {
        $sql = "SELECT COUNT(*) FROM tb_kundendaten WHERE kundennr = ?";
        $count = $this->db->createCommand($sql, [$customerNumber])->queryScalar();
        return $count === 0;
    }
    
    public function checkDuplicates(BuyerData $buyerData): DuplicateCheckResult
    {
        // Komplexe SQL-Query für Duplikat-Prüfung
        $sql = "..."; // Aus ValidateDuplicate
        $rows = $this->db->createCommand($sql, [...])->queryAll();
        
        return $this->mapToDuplicateResult($rows);
    }
    
    public function generateNewCustomerNumber(): string
    {
        $sql = "SELECT getNewBuyerOutID() as newkdnr";
        return $this->db->createCommand($sql)->queryScalar();
    }
    
    private function mapToEntity(array $row): BuyerEntity
    {
        // Mapping von DB-Row zu Entity
        return BuyerEntity::fromArray($row);
    }
}
4.2. AddressRepository
Datei: backend/modules/core/repositories/AddressRepository.php

Code-Struktur:

class AddressRepository implements AddressRepositoryInterface
{
    private $db;
    
    public function create(int $buyerId, AddressEntity $address): AddressEntity
    {
        $sql = "INSERT INTO tb_kundendaten_zusatz (...) VALUES (...)";
        $this->db->createCommand($sql, [...])->execute();
        
        // Stored Procedure
        $this->db->createCommand("CALL kd_adresse_z(?)", [$address->getId()])->execute();
        
        return $address;
    }
    
    public function update(int $addressId, AddressEntity $address): void
    {
        $sql = "UPDATE tb_kundendaten_zusatz SET ... WHERE id = ?";
        $this->db->createCommand($sql, [...])->execute();
        
        $this->db->createCommand("CALL kd_adresse_z(?)", [$addressId])->execute();
    }
    
    public function findMainAddress(int $buyerId): ?AddressEntity
    {
        $sql = "SELECT * FROM tb_kundendaten_zusatz WHERE internekdnr = ? AND maindata = 1";
        $row = $this->db->createCommand($sql, [$buyerId])->queryOne();
        
        return $row ? $this->mapToEntity($row) : null;
    }
    
    public function findByReference(int $buyerId, string $reference): ?AddressEntity
    {
        $sql = "SELECT * FROM tb_kundendaten_zusatz WHERE internekdnr = ? AND reference = ?";
        $row = $this->db->createCommand($sql, [$buyerId, $reference])->queryOne();
        
        return $row ? $this->mapToEntity($row) : null;
    }
    
    public function generateNewAddressId(): int
    {
        // Generierung neuer ID
        $sql = "SELECT ...";
        return $this->db->createCommand($sql)->queryScalar();
    }
}
4.3. Weitere Repositories
BankRepository - für Bankdaten
UserRepository - für mlm_users und mlm_wbo_users
SponsorRepository - für Partner/Sponsor-Daten
VoucherRepository - für Gutscheine
InterestingRepository - für Interessenten
CountryRepository - für Länder
WarehouseRepository - für Lager
5. Framework Layer
Bleibt unverändert:

Yii2 Framework
Datenbankverbindungen
Sicherheit
Routing
Dependency Injection Container
Mapping: Alte → Neue Struktur
Aktuelle Funktion	Neue Struktur
Buyer::Create()	BuyerCreationOrchestration::createBuyer()
Buyer::ValidateData()	ValidateBuyerDataFunction::validate()
Buyer::ValidateVaucher()	ValidateVoucherFunction::validate()
Buyer::setAgentByEmail()	DetermineSponsorFunction::determineByEmail()
Buyer::CheckDuplicate()	BuyerRepository::checkDuplicates()
Buyer::getNewBuyerOutID()	BuyerRepository::generateNewCustomerNumber()
Buyer::CreateUserName()	GenerateBuyerIdentifiersFunction::generateUsername()
Buyer::InsertBuyer()	BuyerRepository::create()
Buyer::SaveAdresses()	AddressRepository::create() / AddressRepository::update()
Buyer::SaveBank()	BankRepository::create()
Buyer::SendBuyerMail()	SendEmailFunction::sendBuyerRegistrationEmail()
Cache::CacheBuyers()	CacheService::cacheBuyer()
Direkte SQL-Queries	Alle in Repositories
Vorteile der neuen Struktur
Trennung der Verantwortlichkeiten:

Geschäftslogik ist klar getrennt von Datenzugriff
Jede Funktion hat eine einzige Verantwortlichkeit
Testbarkeit:

Business-Funktionen können ohne Datenbank getestet werden
Repositories können isoliert getestet werden
Orchestrierung kann mit Mocks getestet werden
Wartbarkeit:

Änderungen an Geschäftsregeln → nur Business-Funktionen
Änderungen an Datenbankstruktur → nur Repositories
Framework-Wechsel → nur Repositories und API-Layer
Erweiterbarkeit:

Neue Geschäftsregeln → neue Business-Funktionen
Neue Datenquellen → neue Repository-Implementierungen
Framework-Unabhängigkeit:

Core (Business-Funktionen, Orchestrierung) kann 1:1 auf Yii3 portiert werden
Nur Repositories und API-Layer müssen angepasst werden
Migrationsstrategie
Phase 1: Vorbereitung
Interfaces für alle Repositories definieren
Entity-Klassen erstellen
DTOs (Data Transfer Objects) für Request/Response
Phase 2: Repositories extrahieren
SQL-Queries aus Buyer::Create() in Repositories verschieben
Buyer::Create() verwendet Repositories (noch alte Struktur)
Phase 3: Business-Funktionen extrahieren
Geschäftslogik in separate Funktionen auslagern
Buyer::Create() wird zur Orchestrierung
Phase 4: API-Layer anpassen
Controller ruft Orchestrierung auf
Alte Buyer::Create() wird deprecated
Phase 5: Cleanup
Alte Implementierung entfernen
Tests schreiben
Dokumentation aktualisieren
Beispiel: Vollständiger Ablauf
1. API Request
   POST /api/v1/customers
   {
     "email": "test@example.com",
     "agentid": "10038",
     "adresses": [...]
   }

2. CustomerController::actionCreate()
   - Request formatieren
   - BuyerCreationOrchestration aufrufen

3. BuyerCreationOrchestration::createBuyer()
   - ValidateBuyerDataFunction aufrufen
   - DetermineSponsorFunction aufrufen
   - GenerateBuyerIdentifiersFunction aufrufen
   - BuyerRepository::create() aufrufen
   - AddressRepository::create() aufrufen
   - UserCreationOrchestration aufrufen
   - CacheService aufrufen
   - Response zusammenstellen

4. Business-Funktionen
   - Führen Geschäftsregeln aus
   - Rufen Repositories auf (nur lesend)
   - Keine direkten DB-Zugriffe

5. Repositories
   - Führen SQL-Queries aus
   - Mappen Daten zu Entities
   - Keine Geschäftslogik

6. Response
   {
     "status": "success",
     "data": {
       "internekdnr": 12345,
       "kundennr": "10038",
       "username": "user10038"
     }
   }
Zusammenfassung
Die neue Struktur trennt klar:

API: Request/Response-Handling
Orchestrierung: Koordination des Prozesses
Business-Funktionen: Geschäftsregeln
Repositories: Datenzugriff
Framework: Technische Infrastruktur
Alle aktuellen Funktionen bleiben erhalten, sind aber klar strukturiert und testbar.

Zusammenfassung