Gecko [ v3.cesa.co.za ]

Name	Size	Permission	Date
.htaccess	237 B	-r-xr-xr-x	2026-08-17 03:12
MemberFirmTransformationDeclarationContext.php	520 B	-rwxrwxr-x	2026-05-20 09:05
MemberFirmTransformationPortalService.php	20.02 KB	-rwxrwxr-x	2026-05-20 09:05

Rename

<?php

namespace App\MemberBundle\Service;

use App\MemberBundle\Entity\ADecMemberFirm;
use App\MemberBundle\Entity\ADecTransformation;
use App\MemberBundle\Entity\MemberContact;
use App\MemberBundle\Entity\MemberFirm;
use App\MemberBundle\Entity\MemberFirmTransformation;
use App\MemberBundle\Form\Model\MemberFirmTransformationCapture;
use App\MemberBundle\Repository\MemberContactRepository;
use App\UserBundle\Entity\UserList;
use App\UserBundle\Entity\UserLogin;
use App\UserBundle\Service\MemberPortalUserService;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Security\Core\User\UserInterface;

/**
 * Member portal annual transformation declaration: resolve firm from contacts,
 * load/save current-year rows in ADec_tblMemberFirms and ADec_Transformation.
 * Live tblMemberFirms / tblMemberFirmsTransformation are read-only prefill sources
 * until staff approve copying declaration data into operational tables.
 */
final class MemberFirmTransformationPortalService
{
    /** Keys matching MemberFirmTransformation entity properties / reporting pipeline */
    public const TRANSFORMATION_COUNT_FIELDS = [
        'trans_top_ma', 'trans_top_mc', 'trans_top_mi', 'trans_top_mw', 'trans_top_mn',
        'trans_top_fa', 'trans_top_fc', 'trans_top_fi', 'trans_top_fw', 'trans_top_fn',
        'trans_senior_ma', 'trans_senior_mc', 'trans_senior_mi', 'trans_senior_mw', 'trans_senior_mn',
        'trans_senior_fa', 'trans_senior_fc', 'trans_senior_fi', 'trans_senior_fw', 'trans_senior_fn',
        'trans_prof_ma', 'trans_prof_mc', 'trans_prof_mi', 'trans_prof_mw', 'trans_prof_mn',
        'trans_prof_fa', 'trans_prof_fc', 'trans_prof_fi', 'trans_prof_fw', 'trans_prof_fn',
        'trans_skilled_ma', 'trans_skilled_mc', 'trans_skilled_mi', 'trans_skilled_mw', 'trans_skilled_mn',
        'trans_skilled_fa', 'trans_skilled_fc', 'trans_skilled_fi', 'trans_skilled_fw', 'trans_skilled_fn',
        'trans_semi_ma', 'trans_semi_mc', 'trans_semi_mi', 'trans_semi_mw', 'trans_semi_mn',
        'trans_semi_fa', 'trans_semi_fc', 'trans_semi_fi', 'trans_semi_fw', 'trans_semi_fn',
        'trans_unskill_ma', 'trans_unskill_mc', 'trans_unskill_mi', 'trans_unskill_mw', 'trans_unskill_mn',
        'trans_unskill_fa', 'trans_unskill_fc', 'trans_unskill_fi', 'trans_unskill_fw', 'trans_unskill_fn',
        'trans_temp_ma', 'trans_temp_mc', 'trans_temp_mi', 'trans_temp_mw', 'trans_temp_mn',
        'trans_temp_fa', 'trans_temp_fc', 'trans_temp_fi', 'trans_temp_fw', 'trans_temp_fn',
    ];

public function __construct(
        private readonly MemberContactRepository $memberContactRepository,
        private readonly EntityManagerInterface $entityManager,
    ) {
    }

/**
     * Portal contact for UserList (e-mail match) or UserLogin (contact_id).
     */
    public function resolvePortalContact(UserInterface $user): ?MemberContact
    {
        if ($user instanceof UserLogin) {
            $contactId = $user->getContactId();
            if ($contactId === null || $contactId <= 0) {
                return null;
            }

return $this->memberContactRepository->findByContactIdWithMemberFirm(
                $contactId,
                MemberPortalUserService::ALLOWED_MEMBER_STATUSES,
            );
        }

if ($user instanceof UserList) {
            $norm = self::normalizeEmail($user->getEMailAddressString());
            if ($norm === '') {
                return null;
            }

return $this->memberContactRepository->findContactByNormalizedEmailWithMemberFirm($norm);
        }

return null;
    }

public function getCurrentDeclarationYear(): int
    {
        return (int) date('Y');
    }

public function prepareDeclarationCapture(MemberFirm $liveFirm): MemberFirmTransformationDeclarationContext
    {
        $year = $this->getCurrentDeclarationYear();
        $liveFirmId = (int) $liveFirm->getId();

$currentFirm = $this->findDeclarationFirmForYear($liveFirmId, $year);
        $currentTrans = $currentFirm !== null
            ? $this->findDeclarationTransformationForYear($liveFirmId, $year, $currentFirm)
            : null;

if ($currentFirm !== null) {
            return new MemberFirmTransformationDeclarationContext(
                $this->buildCaptureFromADec($currentFirm, $currentTrans),
                $year,
                null,
                true,
            );
        }

for ($priorYear = $year - 1; $priorYear >= 2000; --$priorYear) {
            $priorFirm = $this->findDeclarationFirmForYear($liveFirmId, $priorYear);
            if ($priorFirm === null) {
                continue;
            }
            $priorTrans = $this->findDeclarationTransformationForYear($liveFirmId, $priorYear, $priorFirm);
            if (!$this->declarationYearHasTransformationData($priorFirm, $priorTrans)) {
                continue;
            }

return new MemberFirmTransformationDeclarationContext(
                $this->buildCaptureFromADec($priorFirm, $priorTrans),
                $year,
                $priorYear,
                false,
            );
        }

$liveTrans = $liveFirm->getMemberTransformation();
        if ($liveTrans instanceof MemberFirmTransformation
            && $this->declarationYearHasTransformationData($liveFirm, $liveTrans)) {
            return new MemberFirmTransformationDeclarationContext(
                $this->buildCaptureFromEntities($liveFirm, $liveTrans),
                $year,
                null,
                false,
            );
        }

$emptyTrans = new MemberFirmTransformation();

return new MemberFirmTransformationDeclarationContext(
            $this->buildCaptureFromEntities($liveFirm, $emptyTrans),
            $year,
            null,
            false,
        );
    }

public function sumTransformationHeadcount(array $trans): int
    {
        $sum = 0;
        foreach (self::TRANSFORMATION_COUNT_FIELDS as $field) {
            $sum += (int) ($trans[$field] ?? 0);
        }

return $sum;
    }

public function validateStaffHeadcountMatchesGrid(MemberFirmTransformationCapture $capture): ?string
    {
        $sum = $this->sumTransformationHeadcount($capture->trans);
        $total = $capture->totalStaff;

if ($total === null) {
            if ($sum > 0) {
                return sprintf(
                    'Enter total staff. It must equal the sum of all headcount fields (%d).',
                    $sum,
                );
            }

return null;
        }

if ($total !== $sum) {
            return sprintf(
                'Total staff (%d) must equal the sum of all occupational band and demographic headcounts (%d).',
                $total,
                $sum,
            );
        }

return null;
    }

public function saveDeclaration(
        MemberFirm $liveFirm,
        MemberFirmTransformationCapture $capture,
    ): void {
        $headcountError = $this->validateStaffHeadcountMatchesGrid($capture);
        if ($headcountError !== null) {
            throw new \InvalidArgumentException($headcountError);
        }

$year = $this->getCurrentDeclarationYear();
        $liveFirmId = (int) $liveFirm->getId();

$adecFirm = $this->findDeclarationFirmForYear($liveFirmId, $year);
        if (!$adecFirm instanceof ADecMemberFirm) {
            $adecFirm = $this->createADecMemberFirmFromLive($liveFirm, $year);
        }
        $this->applyCaptureToADecMemberFirm($adecFirm, $capture);
        $adecFirm->setDeclarationYear($year);

$adecTrans = $this->findDeclarationTransformationForYear($liveFirmId, $year, $adecFirm);
        if (!$adecTrans instanceof ADecTransformation) {
            $adecTrans = new ADecTransformation();
            $adecTrans->setMemberFirm($adecFirm);
            $adecTrans->setPrevFirmId($liveFirmId);
            $adecTrans->setDeclarationYear($year);
            $adecFirm->setMemberTransformation($adecTrans);
            $this->entityManager->persist($adecTrans);
        }
        $this->applyCaptureToADecTransformation($adecTrans, $capture);
        $adecTrans->setDeclarationYear($year);

$this->entityManager->persist($adecFirm);
        $this->entityManager->persist($adecTrans);
        $this->entityManager->flush();
    }

public function findDeclarationFirmForYear(int $liveFirmId, int $year): ?ADecMemberFirm
    {
        /** @var \App\MemberBundle\Repository\ADecMemberFirmRepository $repo */
        $repo = $this->entityManager->getRepository(ADecMemberFirm::class);

return $repo->findOneByLiveFirmAndDeclarationYear($liveFirmId, $year);
    }

public function findDeclarationTransformationForYear(
        int $liveFirmId,
        int $year,
        ADecMemberFirm $adecFirm,
    ): ?ADecTransformation {
        $linked = $adecFirm->getMemberTransformation();
        if ($linked instanceof ADecTransformation
            && (int) ($linked->getDeclarationYear() ?? 0) === $year) {
            return $linked;
        }

/** @var \App\MemberBundle\Repository\ADecTransformationRepository $repo */
        $repo = $this->entityManager->getRepository(ADecTransformation::class);

return $repo->findOneByLiveFirmAndDeclarationYear($liveFirmId, $year);
    }

public static function normalizeEmail(?string $email): string
    {
        if ($email === null || $email === '') {
            return '';
        }

return mb_strtolower(trim($email));
    }

public function findMandatedPrincipalContactForUser(UserList $user): ?MemberContact
    {
        $norm = self::normalizeEmail($user->getEMailAddressString());
        if ($norm === '') {
            return null;
        }

return $this->memberContactRepository->findMandatedPrincipalByNormalizedEmail($norm);
    }

public function getMemberFirmForContact(MemberContact $contact): ?MemberFirm
    {
        $office = $contact->getMemberOffice();
        if ($office === null) {
            return null;
        }

return $office->getMemberFirm();
    }

public function getOrCreateTransformation(MemberFirm $firm): MemberFirmTransformation
    {
        $t = $firm->getMemberTransformation();
        if ($t instanceof MemberFirmTransformation) {
            return $t;
        }

$t = new MemberFirmTransformation();
        $t->setMemberFirm($firm);
        $firm->setMemberTransformation($t);
        $this->entityManager->persist($t);

return $t;
    }

public function buildCaptureFromEntities(MemberFirm $firm, MemberFirmTransformation $trans): MemberFirmTransformationCapture
    {
        $c = new MemberFirmTransformationCapture();
        $c->smme = (string) ($firm->getSmme() ?? '');
        if ($c->smme === '') {
            $c->smme = 'NotSpecified';
        }
        $c->blackOwned = (string) ($firm->getBlackOwned() ?? '');
        if ($c->blackOwned === '') {
            $c->blackOwned = 'Less than 10%';
        }
        $c->blackWomenOwned = (string) ($firm->getBlackWomenOwned() ?? '');
        if ($c->blackWomenOwned === '') {
            $c->blackWomenOwned = 'Less than 10%';
        }
        $c->bbbeeLevel = $firm->getBbbeeLevel();
        $c->totalStaff = $firm->getTotalStaff();
        $t = $firm->getThreeYearsAverageTurnover();
        $c->threeYearsAverageTurnover = $t !== null && $t !== '' ? (string) $t : null;

$c->trans = [];
        foreach (self::TRANSFORMATION_COUNT_FIELDS as $field) {
            $getter = $this->getterForTransField($field);
            $c->trans[$field] = $getter !== null ? (int) $trans->{$getter}() : 0;
        }

return $c;
    }

public function applyCaptureToEntities(
        MemberFirm $firm,
        MemberFirmTransformation $trans,
        MemberFirmTransformationCapture $capture,
    ): void {
        $firm->setSmme($capture->smme !== '' ? $capture->smme : null);
        $firm->setBlackOwned($capture->blackOwned !== '' ? $capture->blackOwned : null);
        $firm->setBlackWomenOwned($capture->blackWomenOwned !== '' ? $capture->blackWomenOwned : null);
        $firm->setBbbeeLevel($capture->bbbeeLevel);
        $firm->setTotalStaff($capture->totalStaff);
        if ($capture->threeYearsAverageTurnover === null || $capture->threeYearsAverageTurnover === '') {
            $firm->setThreeYearsAverageTurnover(null);
        } else {
            $firm->setThreeYearsAverageTurnover($capture->threeYearsAverageTurnover);
        }

foreach (self::TRANSFORMATION_COUNT_FIELDS as $field) {
            $v = (int) ($capture->trans[$field] ?? 0);
            $setter = $this->setterForTransField($field);
            if ($setter !== null) {
                $trans->{$setter}($v);
            }
        }
    }

public function saveFirmAndTransformation(MemberFirm $firm, MemberFirmTransformation $trans): void
    {
        $this->entityManager->persist($firm);
        $this->entityManager->persist($trans);
        $this->entityManager->flush();
    }

public function buildCaptureFromADec(ADecMemberFirm $firm, ?ADecTransformation $trans): MemberFirmTransformationCapture
    {
        $c = new MemberFirmTransformationCapture();
        $c->smme = (string) ($firm->getSmme() ?? '');
        if ($c->smme === '') {
            $c->smme = 'NotSpecified';
        }
        $c->blackOwned = (string) ($firm->getBlackOwned() ?? '');
        if ($c->blackOwned === '') {
            $c->blackOwned = 'Less than 10%';
        }
        $c->blackWomenOwned = (string) ($firm->getBlackWomenOwned() ?? '');
        if ($c->blackWomenOwned === '') {
            $c->blackWomenOwned = 'Less than 10%';
        }
        $c->bbbeeLevel = $firm->getBbbeeLevel();
        $c->totalStaff = $firm->getTotalStaff();

$c->trans = [];
        $trans ??= new ADecTransformation();
        $turnover = $trans->getThreeYearsAverageTurnover();
        if (($turnover === null || $turnover === '') && $firm->getThreeYearsAverageTurnover() !== null) {
            $turnover = $firm->getThreeYearsAverageTurnover();
        }
        $c->threeYearsAverageTurnover = $turnover !== null && $turnover !== '' ? (string) $turnover : null;
        foreach (self::TRANSFORMATION_COUNT_FIELDS as $field) {
            $getter = $this->getterForTransField($field);
            $c->trans[$field] = $getter !== null ? (int) $trans->{$getter}() : 0;
        }

return $c;
    }

private function createADecMemberFirmFromLive(MemberFirm $liveFirm, int $year): ADecMemberFirm
    {
        $adec = new ADecMemberFirm();
        $adec->setPrevFirmId((string) $liveFirm->getId());
        $adec->setDeclarationYear($year);
        $adec->setFirmName($liveFirm->getFirmName() ?? '');
        $adec->setMemberStatus($liveFirm->getMemberStatus());
        $adec->setSmme($liveFirm->getSmme());
        $adec->setBlackOwned($liveFirm->getBlackOwned());
        $adec->setBlackWomenOwned($liveFirm->getBlackWomenOwned());
        $adec->setBbbeeLevel($liveFirm->getBbbeeLevel());
        $adec->setTotalStaff($liveFirm->getTotalStaff());
        $this->entityManager->persist($adec);

return $adec;
    }

private function applyCaptureToADecMemberFirm(ADecMemberFirm $firm, MemberFirmTransformationCapture $capture): void
    {
        $firm->setSmme($capture->smme !== '' ? $capture->smme : null);
        $firm->setBlackOwned($capture->blackOwned !== '' ? $capture->blackOwned : null);
        $firm->setBlackWomenOwned($capture->blackWomenOwned !== '' ? $capture->blackWomenOwned : null);
        $firm->setBbbeeLevel($capture->bbbeeLevel);
        $firm->setTotalStaff($capture->totalStaff);
    }

private function applyCaptureToADecTransformation(
        ADecTransformation $trans,
        MemberFirmTransformationCapture $capture,
    ): void {
        foreach (self::TRANSFORMATION_COUNT_FIELDS as $field) {
            $v = (int) ($capture->trans[$field] ?? 0);
            $setter = $this->setterForTransField($field);
            if ($setter !== null) {
                $trans->{$setter}($v);
            }
        }
        if ($capture->threeYearsAverageTurnover !== null && $capture->threeYearsAverageTurnover !== '') {
            $trans->setThreeYearsAverageTurnover($capture->threeYearsAverageTurnover);
        }
    }

private function declarationYearHasTransformationData(
        ADecMemberFirm|MemberFirm $firm,
        ADecTransformation|MemberFirmTransformation|null $trans,
    ): bool {
        if ($firm->getSmme() !== null && $firm->getSmme() !== '') {
            return true;
        }
        if ($firm->getTotalStaff() !== null && $firm->getTotalStaff() > 0) {
            return true;
        }
        if ($trans === null) {
            return false;
        }
        foreach (self::TRANSFORMATION_COUNT_FIELDS as $field) {
            $getter = $this->getterForTransField($field);
            if ($getter !== null && (int) $trans->{$getter}() > 0) {
                return true;
            }
        }

return false;
    }

private function getterForTransField(string $field): ?string
    {
        $map = [
            'trans_top_ma' => 'getTransTopMa', 'trans_top_mc' => 'getTransTopMc', 'trans_top_mi' => 'getTransTopMi',
            'trans_top_mw' => 'getTransTopMw', 'trans_top_mn' => 'getTransTopMn', 'trans_top_fa' => 'getTransTopFa',
            'trans_top_fc' => 'getTransTopFc', 'trans_top_fi' => 'getTransTopFi', 'trans_top_fw' => 'getTransTopFw',
            'trans_top_fn' => 'getTransTopFn',
            'trans_senior_ma' => 'getTransSeniorMa', 'trans_senior_mc' => 'getTransSeniorMc', 'trans_senior_mi' => 'getTransSeniorMi',
            'trans_senior_mw' => 'getTransSeniorMw', 'trans_senior_mn' => 'getTransSeniorMn', 'trans_senior_fa' => 'getTransSeniorFa',
            'trans_senior_fc' => 'getTransSeniorFc', 'trans_senior_fi' => 'getTransSeniorFi', 'trans_senior_fw' => 'getTransSeniorFw',
            'trans_senior_fn' => 'getTransSeniorFn',
            'trans_prof_ma' => 'getTransProfMa', 'trans_prof_mc' => 'getTransProfMc', 'trans_prof_mi' => 'getTransProfMi',
            'trans_prof_mw' => 'getTransProfMw', 'trans_prof_mn' => 'getTransProfMn', 'trans_prof_fa' => 'getTransProfFa',
            'trans_prof_fc' => 'getTransProfFc', 'trans_prof_fi' => 'getTransProfFi', 'trans_prof_fw' => 'getTransProfFw',
            'trans_prof_fn' => 'getTransProfFn',
            'trans_skilled_ma' => 'getTransSkilledMa', 'trans_skilled_mc' => 'getTransSkilledMc', 'trans_skilled_mi' => 'getTransSkilledMi',
            'trans_skilled_mw' => 'getTransSkilledMw', 'trans_skilled_mn' => 'getTransSkilledMn', 'trans_skilled_fa' => 'getTransSkilledFa',
            'trans_skilled_fc' => 'getTransSkilledFc', 'trans_skilled_fi' => 'getTransSkilledFi', 'trans_skilled_fw' => 'getTransSkilledFw',
            'trans_skilled_fn' => 'getTransSkilledFn',
            'trans_semi_ma' => 'getTransSemiMa', 'trans_semi_mc' => 'getTransSemiMc', 'trans_semi_mi' => 'getTransSemiMi',
            'trans_semi_mw' => 'getTransSemiMw', 'trans_semi_mn' => 'getTransSemiMn', 'trans_semi_fa' => 'getTransSemiFa',
            'trans_semi_fc' => 'getTransSemiFc', 'trans_semi_fi' => 'getTransSemiFi', 'trans_semi_fw' => 'getTransSemiFw',
            'trans_semi_fn' => 'getTransSemiFn',
            'trans_unskill_ma' => 'getTransUnskillMa', 'trans_unskill_mc' => 'getTransUnskillMc', 'trans_unskill_mi' => 'getTransUnskillMi',
            'trans_unskill_mw' => 'getTransUnskillMw', 'trans_unskill_mn' => 'getTransUnskillMn', 'trans_unskill_fa' => 'getTransUnskillFa',
            'trans_unskill_fc' => 'getTransUnskillFc', 'trans_unskill_fi' => 'getTransUnskillFi', 'trans_unskill_fw' => 'getTransUnskillFw',
            'trans_unskill_fn' => 'getTransUnskillFn',
            'trans_temp_ma' => 'getTransTempMa', 'trans_temp_mc' => 'getTransTempMc', 'trans_temp_mi' => 'getTransTempMi',
            'trans_temp_mw' => 'getTransTempMw', 'trans_temp_mn' => 'getTransTempMn', 'trans_temp_fa' => 'getTransTempFa',
            'trans_temp_fc' => 'getTransTempFc', 'trans_temp_fi' => 'getTransTempFi', 'trans_temp_fw' => 'getTransTempFw',
            'trans_temp_fn' => 'getTransTempFn',
        ];

return $map[$field] ?? null;
    }

private function setterForTransField(string $field): ?string
    {
        $g = $this->getterForTransField($field);
        if ($g === null) {
            return null;
        }

return 'set' . substr($g, 3);
    }
}