src/StartPlatz/Bundle/StartupBundle/Repository/StartupRepository.php line 2167

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace App\StartPlatz\Bundle\StartupBundle\Repository;
  5. use App\StartPlatz\Bundle\GruendungsstipendiumBundle\Entity\GsJuryAssessment;
  6. use App\StartPlatz\Bundle\MemberBundle\Entity\Team;
  7. use App\StartPlatz\Bundle\MetaBundle\Entity\Attribute;
  8. use App\StartPlatz\Bundle\MetaBundle\Entity\Tag;
  9. use App\StartPlatz\Bundle\StartupBundle\Entity\Batch;
  10. use App\StartPlatz\Bundle\StartupBundle\Entity\Program;
  11. use App\StartPlatz\Bundle\StartupBundle\Entity\StartupRelevance;
  12. use DateTime;
  13. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  14. use Doctrine\ORM\QueryBuilder;
  15. use App\StartPlatz\Bundle\StartupBundle\Entity\Application;
  16. use App\StartPlatz\Bundle\StartupBundle\Entity\Startup;
  17. use App\StartPlatz\Bundle\StartupBundle\Entity\StartupAttribute;
  18. use App\StartPlatz\Bundle\UserBundle\Entity\User;
  19. use App\StartPlatz\Bundle\WebsiteBundle\Utility\Utility;
  20. use Doctrine\Persistence\ManagerRegistry;
  22. /**
  23.  * StartupRepository
  24.  *
  25.  * This class was generated by the Doctrine ORM. Add your own custom
  26.  * repository methods below.
  27.  */
  28. class StartupRepository extends ServiceEntityRepository
  29. {
  30.     public function __construct(ManagerRegistry $managerRegistry)
  31.     {
  32.         parent::__construct($managerRegistry, Startup::class);
  33.     }
  34.     //Connect
  35.     public function find4SearchConnectStartup()
  36.     {
  37.         $connection = $this->getEntityManager()->getConnection();
  38.         $sql ="SELECT t.name, t.previousName, t.status, t.shortName, t.id, s.tags, s.slug
  39.         FROM sp_startup_profiles s, sp_teams t
  40.         WHERE s.teamId = t.id and s.visibility IN ('sp-connect', 'public')
  41.         ";
  42.         return $connection->fetchAllAssociative($sql, []);
  43.     }
  45.     public function synchronizeStartupAndTeamEntities($criteria, $order = [])
  46.     {
  47.         $qb = $this->getEntityManager()->createQueryBuilder();
  48.         $responseContent = [];
  49.         $qb->select('s.id as startupId, s.teamId as startupTeamId, t.id as teamId')
  50.             ->from(Startup::class, 's')
  51.             ->innerJoin(Team::class, 't', 'with', 's.teamId = t.id')
  52.             ->where('s.teamId != t.id')
  53.         ;
  55.         if ($criteria) {
  56.             foreach($criteria as $field =>$value) {
  57.                 if ($field == 'categories' or $field == 'tags') {
  58.                     $qb->andWhere('s.'. $field . " LIKE '%" . $value . "%'");
  59.                 } elseif ($value == 'IS NULL' or $value == null) {
  60.                     $qb->andWhere('s.'. $field . " IS NULL");
  61.                 } elseif (is_array($value)) {
  62.                     $qb->andWhere('s.'. $field . " IN (:{$field})");
  63.                     $qb->setParameter($field, array_keys($value));
  64.                 } else {
  65.                     $qb->andWhere('s.'. $field . ' = :' . $field);
  66.                     $qb->setParameter($field, $value);
  67.                 }
  68.             }
  69.         }
  71.         $items = $qb->getQuery()->getResult();
  72.         foreach ($items as $item) {
  73.             $responseContent[] = $this->setField('teamId', $item['teamId'], $item['startupId']);
  74.         }
  76.         return $responseContent;
  77.     }
  79.     /**
  80.      * Check if a team is in the current batch.
  81.      *
  82.      * @deprecated UP-024: The 'startplatz' field was removed from Startup entity.
  83.      *             This method now returns false. The concept of "currentBatch" needs
  84.      *             to be reimplemented via Participation entity if still needed.
  85.      */
  86.     public function isCurrentBatch(Team $team): bool
  87.     {
  88.         // UP-024: The 'startplatz' field was removed from Startup.
  89.         // Previously this checked for startplatz='currentBatch'.
  90.         // TODO: Reimplement via Participation entity if this functionality is still needed.
  91.         return false;
  92.     }
  94.     public function findFilterMultiple($criteria, $field, $delimiter)
  95.     {
  96.         $qb = $this->getEntityManager()->createQueryBuilder();
  97.         $qb->select(
  98.             's.'. $field
  99.         );
  100.         $qb->from(Startup::class, 's')
  101.             ->where('s.'. $field . " > '' ")
  102.         ;
  104.         $qb = $this->setCriteria($qb, $criteria);
  106.         $qb->orderBy('s.name', 'ASC');
  108.         $entities = $qb->getQuery()->getResult();
  109.         if ($field == 'todos') {
  110.             return Utility::countJsonTags($entities, $field, $delimiter);
  111.         } else {
  112.             return Utility::countTags($entities, $field, $delimiter);
  113.         }
  114.     }
  116.     public function transferStartupIdToWinner($winnerId, $looserId)
  117.     {
  118.         $connection = $this->getEntityManager()->getConnection();
  119.         $responseContent = [];
  120.         $tables = [
  121.             'StartupLifecycleEvent' => 'sp_startup_lifecycle_events',
  122.             'Application'           => 'sp_applications',
  123.         ];
  124.         foreach ($tables as $key => $name) {
  125.             $sql ="UPDATE {$name} s
  126.               SET s.startupId = ". $winnerId ."
  127.               WHERE s.startupId = " . $looserId;
  128.             $connection->executeQuery($sql);
  129.             $responseContent[] = "{$name} {$looserId} transfered to startup {$winnerId}";
  130.             $responseContent[] = "{$sql}";
  131.         }
  133.         $tables = [
  134.             'StartupAttribute' => 'sp_startup_attributes',
  135.             'StartupRelevance' => 'sp_startup_relevance',
  136.         ];
  138.         foreach ($tables as $key => $name) {
  139.             $sql ="DELETE FROM {$name} WHERE startupId = " . $looserId;
  140.             $connection->executeQuery($sql);
  141.             $responseContent[] = "{$looserId} deleted from table {$name} ";
  142.             $responseContent[] = "{$sql}";
  143.         }
  145.         $sql = "DELETE FROM sp_startup_profiles WHERE id = :looserId";
  146.         $connection->executeQuery($sql, ['looserId' => $looserId]);
  147.         $responseContent[] = "{$looserId} deleted form table sp_startup_profiles";
  148.         $responseContent[] = "{$sql}";
  150.         return $responseContent;
  151.     }
  153.     public function saveStartup(Startup $startup, $adminEmail)
  154.     {
  155.         $em = $this->getEntityManager();
  156.         $now = new DateTime();
  158.         $startup->setLastModified($now);
  159.         $startup->setLastChangedBy($adminEmail);
  161.         $em->persist($startup);
  162.         $em->flush();
  163.         return $startup;
  164.     }
  166.     public function updateTeamName($teamId, $teamName)
  167.     {
  168.         $em = $this->getEntityManager();
  169.         if ($startup = $em->getRepository(Startup::class)->findOneBy(['teamId'=>$teamId])) {
  170.             $startup->setName($teamName);
  171.             $startup = $this->updateSlugByStartupName($startup);
  173.             $em->persist($startup);
  174.             $em->flush();
  175.         }
  176.         return true;
  177.     }
  180.     public function checkConnectionWithTeams(Startup $startup, $user)
  181.     {
  182.         $em = $this->getEntityManager();
  183.         $now = new DateTime();
  184.         $response = '';
  186.         if ($teamId = $startup->getTeamId()) {
  187.             if ($team = $em->getRepository(Team::class)->find($teamId)) {
  188.                 if ($team->getStartupId() != $startup->getId()) {
  189.                     $team->setStartupId($startup->getId());
  190.                     $team->setLastModified($now);
  191.                     $team->setLastChangeUser($user->getEmail());
  193.                     $em->persist($team);
  194.                     $em->flush();
  195.                     $response = "Team updated with new startupId {$startup->getId()}";
  196.                 }
  197.             } else {
  198.                 $response = "ERROR team with {$startup->getTeamId()} does not exist";
  199.             }
  200.         }
  201.         return $response;
  202.     }
  204.     public function setStartupCompletenessScore(Startup $startup)
  205.     {
  206.         $credits = [
  207.             "oneSentencePitch" => 200,
  208.             "logoUrl"          => 150,
  209.             "contactEmail"     =>  40,
  210.             "website"        =>  40,
  211.             "industry"       =>  20,
  212.             "foundationYear" => 20,
  213.             "customerFocus"  => 20,
  214.             "stage"       => 20,
  215.             "linkedin"    =>  30,
  216.             "twitter"     =>  15,
  217.             "instagram"   =>  15,
  218.             "xing"        =>  10,
  219.             "facebook"    =>  10,
  220.         ];
  223.         $completenessScore = 0;
  224.         foreach ($credits as $field => $value) {
  225.             $method = 'get' . ucfirst($field);
  226.             if ($startup->$method()) {
  227.                 $completenessScore += $value;
  228.             }
  229.         }
  230.         $tags = explode(',', str_replace('#', '', (string) $startup->getTags()));
  231.         if (in_array('accelerator', $tags)) {
  232.             $completenessScore += 50;
  233.         }
  234.         $tags = explode(',', str_replace('#', '', (string) $startup->getTags()));
  235.         if (in_array('gruenderstipendium', $tags)) {
  236.             $completenessScore += 30;
  237.         }
  239.         // UP-024: batch field removed from Startup - participation count could be used instead
  240.         // For now, removed from score calculation
  242.         if ($startup->getStage() == 'closed') {
  243.             $completenessScore = 0;
  244.         }
  246.         return $completenessScore;
  247.     }
  249.     public function updateScoreByEditTeam(Startup $startup)
  250.     {
  251.         $em = $this->getEntityManager();
  252.         $storedCompletenessScore = $startup->getScore();
  253.         $updatedCompletenessScore = $this->setStartupCompletenessScore($startup);
  254.         if ($startup->getScore() != $updatedCompletenessScore) {
  255.             $startup->setScore($updatedCompletenessScore);
  256.         }
  257.         return $startup;
  258.     }
  260.     public function getLatestEntriesByTeamTags($tag, $maxResults)
  261.     {
  262.         $qb = $this->getEntityManager()->createQueryBuilder();
  263.         $qb->select(
  264.             's'
  265.         );
  266.         $qb->from(Startup::class, 's')
  267.             ->from(Team::class, 't')
  268.             ->where('s.teamId = t.id')
  269.             ->andWhere("t.tags LIKE :tag")
  270.             ->setMaxResults($maxResults)
  271.             ->setParameter('tag', "%{$tag}%")
  272.         ;
  273.         $qb->orderBy('s.lastModified', 'DESC');
  274.         $startups = $qb->getQuery()->getResult();
  276.         $qb = $this->getEntityManager()->createQueryBuilder();
  277.         $qb->select(
  278.             't'
  279.         );
  280.         $qb->from(Startup::class, 's')
  281.             ->from(Team::class, 't')
  282.             ->where('s.teamId = t.id')
  283.             ->andWhere("t.tags LIKE :tag")
  284.             ->setMaxResults($maxResults)
  285.             ->setParameter('tag', "%{$tag}%")
  286.         ;
  287.         $qb->orderBy('s.lastModified', 'DESC');
  288.         $teams = $qb->getQuery()->getResult();
  289.         $startupIds = array_map(fn (Team $entity) => $entity->getStartupId(), $teams);
  290.         $teams = array_combine($startupIds, $teams);
  292.         return ['startups' => $startups, 'teams' => $teams];
  293.     }
  294.     public function getLatestEntriesByTeamCategory($category, $maxResults)
  295.     {
  296.         $qb = $this->getEntityManager()->createQueryBuilder();
  297.         $qb->select(
  298.             's'
  299.         );
  300.         $qb->from(Startup::class, 's')
  301.             ->from(Team::class, 't')
  302.             ->where('s.teamId = t.id')
  303.             ->andWhere("t.categories LIKE :tag")
  304.             ->setMaxResults($maxResults)
  305.             ->setParameter('tag', "%{$category}%")
  306.         ;
  307.         $qb->orderBy('s.lastModified', 'DESC');
  308.         $startups = $qb->getQuery()->getResult();
  310.         $qb = $this->getEntityManager()->createQueryBuilder();
  311.         $qb->select(
  312.             't'
  313.         );
  314.         $qb->from(Startup::class, 's')
  315.             ->from(Team::class, 't')
  316.             ->where('s.teamId = t.id')
  317.             ->andWhere("t.categories LIKE :tag")
  318.             ->setMaxResults($maxResults)
  319.             ->setParameter('tag', "%{$category}%")
  320.         ;
  321.         $qb->orderBy('s.lastModified', 'DESC');
  322.         $teams = $qb->getQuery()->getResult();
  323.         $startupIds = array_map(fn (Team $entity) => $entity->getStartupId(), $teams);
  324.         $teams = array_combine($startupIds, $teams);
  326.         return ['startups' => $startups, 'teams' => $teams];
  327.     }
  328.     public function getLatestEntriesByStartupTags($tag, $maxResults)
  329.     {
  330.         $qb = $this->getEntityManager()->createQueryBuilder();
  331.         $qb->select(
  332.             's'
  333.         );
  334.         $qb->from(Startup::class, 's')
  335.             ->from(Team::class, 't')
  336.             ->where('s.teamId = t.id')
  337.             ->andWhere("s.tags LIKE :tag")
  338.             ->setMaxResults($maxResults)
  339.             ->setParameter('tag', "%{$tag}%")
  340.         ;
  341.         $qb->orderBy('s.lastModified', 'DESC');
  342.         $startups = $qb->getQuery()->getResult();
  344.         $qb = $this->getEntityManager()->createQueryBuilder();
  345.         $qb->select(
  346.             't'
  347.         );
  348.         $qb->from(Startup::class, 's')
  349.             ->from(Team::class, 't')
  350.             ->where('s.teamId = t.id')
  351.             ->andWhere("s.tags LIKE :tag")
  352.             ->setMaxResults($maxResults)
  353.             ->setParameter('tag', "%{$tag}%")
  354.         ;
  355.         $qb->orderBy('s.lastModified', 'DESC');
  356.         $teams = $qb->getQuery()->getResult();
  357.         $startupIds = array_map(fn (Team $entity) => $entity->getStartupId(), $teams);
  358.         $teams = array_combine($startupIds, $teams);
  360.         return ['startups' => $startups, 'teams' => $teams];
  361.     }
  363.     public function removeStartup(Startup $startup)
  364.     {
  365.         $em = $this->getEntityManager();
  367.         $em->remove($startup);
  368.         $em->flush();
  370.         return "Startup removed";
  371.     }
  373.     public function setField($field, $action, $id, $adminEmail = "system@")
  374.     {
  375.         $em = $this->getEntityManager();
  377.         if (!$startup = $this->findOneBy(['id' => $id])) {
  378.             return 'ERROR: entity not found';
  379.         }
  381.         switch ($field) {
  382.             case "vorPitchOnly":
  383.                 $startup->setPitchPosition('99');
  384.                 $startup->setApplicationStatus('applied');
  385.                 $startup->setBatchStatus('pre pitch');
  386.                 break;
  387.             default:
  388.                 $method = 'set' . ucfirst((string) $field);
  389.                 $startup->$method($action);
  390.                 break;
  391.         }
  394.         $startup->setLastModified(new DateTime());
  396.         $logText = "field  {$field}  set to {$action}";
  397.         $startup->setLastChangeUser($adminEmail);
  398.         $startup->setHistory(
  399.             "==== {$startup->getLastModified()->format('Y-m-d')} by {$startup->getLastChangeUser()}==="
  400.             . PHP_EOL . $logText   . PHP_EOL .$startup->getHistory()
  401.         );
  403.         $em->persist($startup);
  404.         $em->flush();
  406.         return $logText;
  407.     }
  409.     public function setFieldByAjaxConnect($field, $action, Startup $startup, $user)
  410.     {
  411.         $em = $this->getEntityManager();
  413.         $adminEmail = $user->getEmail();
  415.         $method = 'set' . ($field);
  416.         $startup->$method($action);
  418.         $startup->setLastModified(new DateTime());
  419.         $startup->setLastChangeUser($user->getEmail());
  421.         $logText = "{$field}: $action";
  422.         $userType = $user->getIsAdmin() ? 'admin ' : 'member ';
  423.         $startup->setHistory(
  424.             "==== {$startup->getLastModified()->format('Y-m-d')} by {$userType} {$startup->getLastChangeUser()}==="
  425.             . PHP_EOL . $logText   . PHP_EOL .$startup->getHistory()
  426.         );
  427.         $em->persist($startup);
  428.         $em->flush();
  429.         //sync with team
  430.         if($team = $em->getRepository(Team::class)->find($startup->getTeamId())) {
  431.             $em->getRepository(Team::class)->syncDataWithStartup($team, $startup);
  432.         }
  433.         switch ($field) {
  434.             case 'logoUrl':
  435.                 $em->getRepository(Team::class)->unifyLogoUrlPartnerAndStartup($startup->getTeamId(), $action, $adminEmail);
  436.                 $fieldName = 'logo';
  437.                 break;
  438.             case 'imageLink':
  439.                 $fieldName = 'banner';
  440.                 break;
  441.             default:
  442.                 $fieldName = $field;
  443.         }
  444.         return 'Updated ' . $fieldName;
  445.     }
  447.     public function find4Search($visibility)
  448.     {
  449.         $connection = $this->getEntityManager()->getConnection();
  450.         $andWhere = match ($visibility) {
  451.             "public" => " WHERE s.visibility = 'public'",
  452.             "sp-connect" => " WHERE s.visibility IN ('public','sp-connect')",
  453.             default => '',
  454.         };
  455.         $sql ="SELECT s.id, s.name, s.city, s.industry
  456.         FROM sp_startup_profiles s {$andWhere}
  457.         ORDER BY s.name ASC
  458.         ";
  459.         return $connection->fetchAllAssociative($sql, []);
  460.     }
  462.     public function find4SearchWithBatch($batchIds)
  463.     {
  464.         $qb = $this->getEntityManager()->createQueryBuilder();
  465.         $qb->select('s.id, s.name, s.city, s.industry')
  466.            ->from(Startup::class, 's')
  467.            ->join(Application::class, 'a', 'WITH', 's.id = a.startupId')
  468.            ->where('a.batchId in (:batchIds)')
  469.            ->setParameter('batchIds', $batchIds)
  470.         ;
  471.         return $qb->getQuery()->getResult();
  472.     }
  474.     public function findIndustries4Search($visibility)
  475.     {
  476.         $connection = $this->getEntityManager()->getConnection();
  477.         $andWhere = match ($visibility) {
  478.             "public" => " WHERE s.visibility = 'public'",
  479.             "sp-connect" => " WHERE s.visibility IN ('public','sp-connect')",
  480.             default => '',
  481.         };
  482.         $sql ="SELECT s.industry, count(s.id) as total
  483.         FROM sp_startup_profiles s {$andWhere}
  484.         GROUP BY s.industry
  485.         ";
  486.         return $connection->fetchAllAssociative($sql, []);
  487.     }
  490.     public function find4Merge($startupId)
  491.     {
  492.         $connection = $this->getEntityManager()->getConnection();
  493.         $sql ="SELECT t.id, t.name, t.contactPerson, t.website, t.status, t.tags
  494.                     FROM sp_startup_profiles t
  495.                     WHERE t.id != :startupId
  496.                     ORDER BY t.id DESC
  497.                     ";
  498.         return $connection->fetchAllAssociative($sql, ['startupId' => $startupId]);
  499.     }
  503.     public function findTags($criteria, $teamId)
  504.     {
  505.         $qb = $this->getEntityManager()->createQueryBuilder();
  506.         $qb->select(
  507.             's.tags'
  508.         );
  509.         $qb->from(Startup::class, 's')
  510.             ->where("s.tags > '' ")
  511.         ;
  513.         $qb = $this->setCriteria($qb, $criteria, $teamId);
  515.         $qb->orderBy('s.name', 'ASC');
  517.         $entities = $qb->getQuery()->getResult();
  518.         return Utility::countHashTags($entities, 'tags');
  519.     }
  521.     public function getListOfIndustries()
  522.     {
  523.         $em = $this->getEntityManager();
  524.         $attributes = $em->getRepository(Attribute::class)->findBy(['name'=>'startup.industry'], ['label'=>'ASC']);
  525.         $labels     = array_map(fn ($entity) => $entity->getLabel(), $attributes);
  526.         $industries = array_combine($labels, $labels);
  528.         /*
  529.         $industries = $this->findIndustries([], 0);
  530.         return array_combine(array_keys($industries), array_keys($industries));
  531.         */
  532.         return $industries;
  533.     }
  535.     public function findIndustries($criteria, $teamId)
  536.     {
  537.         $qb = $this->getEntityManager()->createQueryBuilder();
  538.         $qb->select(
  539.             's.industry'
  540.         );
  541.         $qb->from(Startup::class, 's')
  542.             ->where("s.industry > '' ")
  543.         ;
  545.         $qb = $this->setCriteria($qb, $criteria, $teamId);
  547.         $qb->orderBy('s.name', 'ASC');
  549.         $entities = $qb->getQuery()->getResult();
  550.         return Utility::countHashTags($entities, 'industry');
  551.     }
  553.     public function findAndExpandAggregatesByField($field, $criteria, $teamId, $group='')
  554.     {
  555.         $qb = $this->getEntityManager()->createQueryBuilder();
  556.         $qb->select(
  557.             "s.{$field}"
  558.         );
  559.         $qb->from(Startup::class, 's')
  560.             ->where("s.{$field} > '' ")
  561.         ;
  563.         if ($group) {
  564.             $qb->andWhere("s.{$group} > '' ");
  565.         }
  567.         $qb = $this->setCriteria($qb, $criteria, $teamId);
  569.         $qb->orderBy('s.name', 'ASC');
  571.         $entities = $qb->getQuery()->getResult();
  572.         return Utility::countHashTags($entities, $field, true);
  573.     }
  575.     public function findApplicationsByProgramId($programId)
  576.     {
  577.         $connection = $this->getEntityManager()->getConnection();
  579.         $sqlRheinlandPitchApplicants = "
  580. SELECT a.applicationStatus, a.batchStatus, count(a.id)
  581. FROM   sp_applications a, sp_batches b
  582. WHERE  a.batchId = b.id
  583.   AND a.programId = 1
  584. GROUP BY a.applicationStatus, a.batchStatus;
  586. Probleme macht der Batcht Status setBatchStatus(
  588. gefunden haben wir
  589. 1_winner
  590. 2_podium
  591. 3_pitch
  592. 5_applied
  593. 6_started
  595. vorgesehen sind:
  596. applicant
  597. pitch
  598. pre pitch
  601. SELECT b.id as batchId, b.batchNumber, b.name
  602. FROM   sp_applications a, sp_batches b
  603. WHERE  a.batchId = b.id
  604.   AND a.programId = 1 and a.batchStatus = 'pitch'
  607. GROUP BY b.batchNumber
  608.         ";
  609.         /*
  611.          */
  614.         $sql ="
  615.             SELECT b.id as batchId, b.batchNumber, b.name, count(s.id) as number
  616.             FROM   sp_startup_profiles s, sp_applications a, sp_batches b
  617.             WHERE  s.id = a.startupId and a.batchId = b.id and a.programId = :programId and a.batchStatus = 'pitch'
  618.             GROUP BY b.batchNumber
  619.                     ";
  620.         $result =  $connection->fetchAllAssociative($sql, ['programId'=>$programId]);
  622.         return $result;
  623.     }
  627.     public function findTeamTags($criteria, $teamId)
  628.     {
  629.         $qb = $this->getEntityManager()->createQueryBuilder();
  630.         $qb->select(
  631.             'a.teamTags'
  632.         );
  633.         $qb->from(StartupAttribute::class, 'a')
  634.             ->where('a.teamId = :teamId')
  635.             ->setParameter('teamId', $teamId)
  636.         ;
  637.         $qb->innerJoin(Startup::class, 's', 'WITH', "a.startupId = s.id and a.teamTags > ''")
  638.         ;
  640.         $qb = $this->setCriteria($qb, $criteria, $teamId);
  642.         $qb->orderBy('a.id', 'ASC');
  644.         $entities = $qb->getQuery()->getResult();
  645.         return Utility::countHashTags($entities, 'teamTags');
  646.     }
  648.     /**
  649.      * UP-024: Removed references to fields that no longer exist:
  650.      * - startplatz, accelerator, batch, batchFirst, batchLast, batchYear
  651.      * - rheinlandPitch, pitchNumber, pitchDate, pitchTopic
  652.      */
  653.     public function getFieldsByTemplate($template)
  654.     {
  655.         $fields = match ($template) {
  656.             "rheinland-pitch" => ['id', 'name', 'website', 'todos', 'status', 'tags'],
  657.             "contact" => ['id', 'name', 'website', 'todos', 'status', 'city', 'location', 'contactPerson', 'contactEmail', 'contactTelefon'],
  658.             "startplatz" => ['id', 'name', 'website', 'todos', 'status', 'teamId', 'kiAccelerator'],
  659.             "description" => ['id', 'name', 'website', 'tags', 'oneSentencePitch'],
  660.             "kpi" => ['id', 'name', 'website', 'employeesCount', 'funding', 'investors', 'revenue', 'tags'],
  661.             "industries" => ['id', 'name', 'website', 'todos', 'industry', 'industryCondensed', 'customerFocus', 'businessModel'],
  662.             "logoAndTags" => ['id', 'name', 'website', 'domain', 'logoUrl', 'tags', 'todos'],
  663.             "full" => ['id', 'extId', 'name', 'teamId', 'website', 'domain', 'slug', 'status', 'kiAccelerator', 'todos', 'industry', 'industryCondensed', 'customerFocus', 'businessModel', 'tags', 'foundationYear', 'city', 'location', 'employeesCount', 'funding', 'investors', 'revenue', 'contactPerson', 'contactEmail', 'contactTelefon', 'oneSentencePitch'],
  664.             "default" => ['id', 'teamId', 'name', 'website', 'linkedin', 'contactPerson', 'contactEmail', 'contactTelefon', 'tags', 'oneSentencePitch'],
  665.         };
  666.         return $fields;
  667.     }
  669.     public function countByCriteria($criteria, $teamId)
  670.     {
  671.         $qb = $this->getEntityManager()->createQueryBuilder();
  672.         $qb
  673.             ->select('COUNT(s)')
  674.             ->from(Startup::class, 's')
  675.         ;
  677.         /*
  678.             ->leftJoin(StartupAttribute::class, 'a', 'WITH', 's.id = a.startupId and a.teamId = :teamId')
  679.             ->setParameter('teamId', $teamId)
  680.          */
  682.         if ($criteria) {
  683.             $qb = $this->setCriteria($qb, $criteria, $teamId);
  684.         }
  686.         return $qb->getQuery()->getSingleScalarResult();
  687.     }
  689.     public function findNotInRelevanceTable()
  690.     {
  691.         $qb = $this->getEntityManager()->createQueryBuilder();
  693.         $qb
  694.             ->select('s')
  695.             ->from(Startup::class, 's')
  696.             ->leftJoin(StartupRelevance::class, 'r', 'WITH', 's.id = r.startupId')
  697.             ->where("r.startupId IS NULL")
  698.         ;
  700.         $query = $qb->getQuery();
  702.         $results = $query->getResult();
  704.         return $results;
  705.     }
  707.     public function findAcceleratorAlumnis()
  708.     {
  709.         $qb = $this->getEntityManager()->createQueryBuilder();
  711.         $qb->select('s')
  712.             ->from(Startup::class, 's')
  713.             ->innerJoin(Team::class, 't', 'WITH', 's.teamId = t.id')
  714.             ->where("t.tags LIKE '%accelerator%'")
  715.             ->andWhere("t.tags LIKE '%badge-accelerator%'")
  716.             ->orderBy('s.name', 'ASC')
  717.         ;
  719.         $results = $qb->getQuery()->getResult();
  721.         return $results;
  723.     }
  725.     /**
  726.      * Find all startups that are part of the KI Accelerator program
  727.      * (startups where kiAccelerator field is set)
  728.      *
  729.      * @return Startup[]
  730.      */
  731.     public function findKiAcceleratorStartups(): array
  732.     {
  733.         return $this->createQueryBuilder('s')
  734.             ->where('s.kiAccelerator IS NOT NULL')
  735.             ->orderBy('s.kiAccelerator', 'ASC')
  736.             ->addOrderBy('s.name', 'ASC')
  737.             ->getQuery()
  738.             ->getResult();
  739.     }
  741.     /**
  742.      * Find startups participating in the current Rheinland Pitch
  743.      *
  744.      * @param string $focusStatus The current focus status of the batch
  745.      * @return array Returns an array of Startup entities
  746.      */
  747.     public function findCurrentRheinlandPitchStartups(string $focusStatus): array
  748.     {
  749.         return $this->createQueryBuilder('s')
  750.             // s represents startup entity
  751.             ->select('s')
  752.             // Join with Application table connecting via startupId
  753.             ->innerJoin(Application::class, 'a', 'WITH', 'a.startupId = s.id')
  754.             // Join with Batch table connecting via batchId
  755.             ->innerJoin(Batch::class, 'b', 'WITH', 'a.batchId = b.id')
  756.             // Filter for Rheinland Pitch program (programId = 1)
  757.             ->where('b.programId = :programId')
  758.             // Filter for current batch status
  759.             ->andWhere('b.focusStatus = :focusStatus')
  760.             // Filter for pitch status in applications
  761.             ->andWhere('a.batchStatus = :batchStatus')
  762.             ->setParameter('programId', 1)
  763.             ->setParameter('focusStatus', $focusStatus)
  764.             ->setParameter('batchStatus', 'pitch')
  765.             // Order by pitch presentation order
  766.             ->orderBy('a.pitchPosition', 'ASC')
  767.             ->getQuery()
  768.             ->getResult();
  769.     }
  770.     public function findPaginated($criteria, $teamId, $order = [], $page = 1, $limit = 5)
  771.     {
  772.         $page = (int) $page;
  773.         $limit = (int) $limit;
  774.         $qb = $this->getEntityManager()->createQueryBuilder();
  776.         $qb = $this->setSelect($qb);
  778.         $qb
  779.             ->from(Startup::class, 's')
  780.             ->innerJoin(StartupRelevance::class, 'r', 'WITH', 's.id = r.startupId')
  781.             ->setFirstResult(max(0, $limit * ($page - 1))) // Offset
  782.             ->setMaxResults($limit) // Limit
  783.         ;
  785.         // get rid of
  786.         // ->leftJoin(StartupAttribute::class, 'a', 'WITH', 's.id = a.startupId and a.teamId = :teamId')
  787.         //             ->setParameter('teamId', $teamId)
  789.         if ($criteria) {
  790.             $qb = $this->setCriteria($qb, $criteria, $teamId);
  791.         }
  793.         if ($order) {
  794.             $metadata = $this->getClassMetadata();
  795.             foreach ($order as $key => $value) {
  796.                 if ($key == 'score') {
  797.                     $qb->addOrderBy('r.score', $value);
  798.                 } elseif ($metadata->hasField($key)) {
  799.                     $qb->addOrderBy('s.' . $key, $value);
  800.                 }
  801.                 // UP-024: Skip non-existent fields (removed: pitchDate, etc.)
  802.             }
  803.         } else {
  804.             $qb->addOrderBy('r.score', 'DESC');
  805.             $qb->addOrderBy('s.lastModified', 'DESC');
  806.         }
  808.         $query = $qb->getQuery();
  810.         $results = $query->getResult();
  812.         return $results;
  813.     }
  815.     /**
  816.      * Paginated startup search with relevance sorting for SP-Connect.
  817.      * Relevance: logo → pitch → industry → relevance score → recency.
  818.      */
  819.     public function findPaginatedWithSearch(array $criteria, $teamId, ?string $search, int $page = 1, int $limit = 72): array
  820.     {
  821.         $qb = $this->getEntityManager()->createQueryBuilder();
  822.         $qb = $this->setSelect($qb);
  824.         $qb->from(Startup::class, 's')
  825.             ->innerJoin(StartupRelevance::class, 'r', 'WITH', 's.id = r.startupId')
  826.             ->setFirstResult(max(0, $limit * ($page - 1)))
  827.             ->setMaxResults($limit);
  829.         if ($criteria) {
  830.             $qb = $this->setCriteria($qb, $criteria, $teamId);
  831.         }
  833.         if ($search) {
  834.             $qb->andWhere('(s.name LIKE :search OR s.industry LIKE :search OR s.oneSentencePitch LIKE :search)')
  835.                 ->setParameter('search', '%' . $search . '%');
  837.             // Search relevance: name match first, then industry, then pitch
  838.             $qb->addSelect("CASE WHEN s.name LIKE :search THEN 0 WHEN s.industry LIKE :search THEN 1 ELSE 2 END AS HIDDEN sortSearchRelevance")
  839.                 ->addOrderBy('sortSearchRelevance', 'ASC');
  840.         }
  842.         // Profile completeness sort: logo > pitch > score > recency
  843.         $qb->addSelect("CASE WHEN s.logoUrl IS NOT NULL AND s.logoUrl != '' THEN 0 ELSE 1 END AS HIDDEN sortLogo")
  844.             ->addSelect("CASE WHEN s.oneSentencePitch IS NOT NULL AND s.oneSentencePitch != '' THEN 0 ELSE 1 END AS HIDDEN sortPitch")
  845.             ->addOrderBy('sortLogo', 'ASC')
  846.             ->addOrderBy('sortPitch', 'ASC')
  847.             ->addOrderBy('r.score', 'DESC')
  848.             ->addOrderBy('s.lastModified', 'DESC');
  850.         return $qb->getQuery()->getResult();
  851.     }
  853.     /**
  854.      * Count startups matching criteria + search for SP-Connect pagination.
  855.      */
  856.     public function countWithSearch(array $criteria, $teamId, ?string $search): int
  857.     {
  858.         $qb = $this->getEntityManager()->createQueryBuilder()
  859.             ->select('COUNT(s)')
  860.             ->from(Startup::class, 's')
  861.             ->innerJoin(StartupRelevance::class, 'r', 'WITH', 's.id = r.startupId');
  863.         if ($criteria) {
  864.             $qb = $this->setCriteria($qb, $criteria, $teamId);
  865.         }
  867.         if ($search) {
  868.             $qb->andWhere('(s.name LIKE :search OR s.industry LIKE :search OR s.oneSentencePitch LIKE :search)')
  869.                 ->setParameter('search', '%' . $search . '%');
  870.         }
  872.         return (int) $qb->getQuery()->getSingleScalarResult();
  873.     }
  875.     /**
  876.      * UP-024: Removed fields that no longer exist on Startup entity:
  877.      * - startplatz, accelerator, batch, batchLast, batchFirst, batchYear
  878.      * - rheinlandPitch, pitchNumber, pitchDate, pitchTopic
  879.      * - gruenderstipendium, gsJury, gsStatus
  880.      * - hasBadgeStartplatz
  881.      * These are now managed via Participation entity.
  882.      */
  883.     private function setSelect($qb)
  884.     {
  885.         return $qb
  886.             ->select('s.id', 's.extId', 's.visibility', 's.teamId', 's.name', 's.status', 's.location', 's.city'
  887.                 , 's.website', 's.domain', 's.slug', 's.linkedin', 's.twitter', 's.logoUrl', 's.stage'
  888.                 , 's.kiAccelerator'
  889.                 , 's.industry', 's.industryCondensed', 's.customerFocus', 's.businessModel', 's.tags', 's.todos'
  890.                 , 's.foundationYear', 's.funding', 's.oneSentencePitch'
  891.                 , 's.employeesCount', 's.revenue', 's.investors'
  892.                 , 's.contactPerson', 's.contactEmail', 's.contactTelefon', 's.lastModified', 's.history', 's.lastChangeUser', 's.createdAt'
  893.                 , 'r.score'
  894.             )
  895.         ;
  896.     }
  898.     public function findNotPaginated($criteria, $teamId, $order)
  899.     {
  900.         $qb = $this->getEntityManager()->createQueryBuilder();
  902.         $qb = $this->setSelect($qb);
  904.         $qb
  905.             ->from(Startup::class, 's')
  906.             ->innerJoin(StartupRelevance::class, 'r', 'WITH', 's.id = r.startupId')
  907.             ->leftJoin(StartupAttribute::class, 'a', 'WITH', 's.id = a.startupId and a.teamId = :teamId')
  908.             ->setParameter('teamId', $teamId)
  909.         ;
  911.         if ($criteria) {
  912.             $qb = $this->setCriteria($qb, $criteria, $teamId);
  913.         }
  915.         if ($order) {
  916.             $metadata = $this->getClassMetadata();
  917.             foreach ($order as $key => $value) {
  918.                 if ($metadata->hasField($key)) {
  919.                     $qb->addOrderBy('s.' . $key, $value);
  920.                 }
  921.                 // UP-024: Skip non-existent fields (removed: pitchDate, etc.)
  922.             }
  923.         } else {
  924.             $qb->addOrderBy('r.score', 'DESC');
  925.         }
  927.         $query = $qb->getQuery();
  928.         $results = $query->getResult();
  930.         return $results;
  931.     }
  933.     public function findSingleStartupByVisibility($id, $visibility)
  934.     {
  935.         $qb = $this->getEntityManager()->createQueryBuilder();
  937.         $qb
  938.             ->select('s')
  939.             ->from(Startup::class, 's')
  940.             ->where('s.id = :id')
  941.             ->setParameter('id', $id)
  942.         ;
  943.         switch ($visibility) {
  944.             case "public":
  945.                 $qb->andWhere("s.visibility = 'public' ");
  946.                 break;
  947.             case "sp-connect":
  948.                 $qb->andWhere("s.visibility IN ('public','sp-connect')");
  949.                 break;
  950.             default:
  951.                 break;
  952.         }
  954.         return $qb->getQuery()->getOneOrNullResult();
  955.     }
  956.     /*
  957.              if ($criteria){
  958.             foreach($criteria as $field =>$value) {
  959.                 if ($field == 'categories' or $field == 'tags'){
  960.                     $qb->andWhere('t.'. $field . " LIKE '%" . $value . "%'");
  961.                 } elseif ($value == 'IS NULL' or $value == null) {
  962.                     $qb->andWhere('t.'. $field . " IS NULL" );
  963.                 } elseif (is_array($value) ) {
  964.                     $qb->andWhere('t.'. $field . " IN (:{$field})" );
  965.                     $qb->setParameter($field, array_keys($value));
  966.                 }
  967.                 else {
  968.                     $qb->andWhere('t.'. $field . ' = :' . $field);
  969.                     $qb->setParameter($field, $value);
  970.                 }
  971.             }
  972.         }
  974.      */
  976.     private function setCriteria(QueryBuilder $qb, $criteria, $teamId = 0)
  977.     {
  978.         foreach($criteria as $field =>$value) {
  979.             switch ($field) {
  980.                 case "teamTags":
  981.                     $qb->innerJoin(StartupAttribute::class, 'b', 'WITH', 's.id = b.startupId and b.teamId = :teamIdInnerJoin');
  982.                     $qb->andWhere('b.'. $field . ' LIKE :' . $field);
  983.                     $qb->setParameter($field, "%{$value}%");
  984.                     $qb->setParameter('teamIdInnerJoin', $teamId);
  985.                     break;
  986.                 case "batchNumber":
  987.                     $qb->innerJoin(Application::class, 'ap', 'WITH', 's.id = ap.startupId and ap.programId = 1');
  988.                     $qb->innerJoin(Batch::class, 'batch', 'WITH', 'ap.batchId = batch.id');
  989.                     $qb->andWhere('batch.'. $field . ' LIKE :' . $field);
  990.                     $qb->setParameter($field, "%{$value}%");
  991.                     break;
  992.                 // UP-024: gsStatus field removed from Startup - filter via Participation instead
  994.                 case "visibility":
  995.                     switch ($value) {
  996.                         case "public":
  997.                             $qb->andWhere('s.'. $field . ' = :' . $field);
  998.                             $qb->setParameter($field, $value);
  999.                             break;
  1000.                         case "sp-connect":
  1001.                             $qb->andWhere("s.visibility IN ('public','sp-connect')");
  1002.                             break;
  1003.                         default:
  1004.                             break;
  1005.                     }
  1006.                     break;
  1007.                 case "team":
  1008.                     $qb->andWhere('s.teamId > 0');
  1009.                     break;
  1010.                 case "todos":
  1011.                 case "tags":
  1012.                     // UP-024: pitchNumber removed - field no longer exists on Startup entity
  1013.                     $qb->andWhere('s.'. $field . ' LIKE :' . $field);
  1014.                     $qb->setParameter($field, "%{$value}%");
  1015.                     break;
  1016.                 case "isBookmarked":
  1017.                     $qb->innerJoin(StartupAttribute::class, 'b', 'WITH', 's.id = b.startupId and b.teamId = :teamIdInnerJoin');
  1018.                     $qb->andWhere('b.'. $field . ' = 1');
  1019.                     $qb->setParameter('teamIdInnerJoin', $teamId);
  1020.                     break;
  1021.                 default:
  1022.                     // Skip unknown fields to prevent QueryException for removed fields (e.g., startplatz)
  1023.                     $metadata = $this->getClassMetadata();
  1024.                     if (!$metadata->hasField($field) && !$metadata->hasAssociation($field)) {
  1025.                         continue 2; // continue the foreach loop
  1026.                     }
  1028.                     if ($value == 'IS NULL' or $value == null) {
  1029.                         $qb->andWhere('s.'. $field . " IS NULL");
  1030.                     } elseif ($value == 'not empty') {
  1031.                         $qb->andWhere('s.'. $field . " > '' ");
  1032.                     } elseif (is_array($value)) {
  1033.                         $qb->andWhere('s.'. $field . " IN (:{$field})");
  1034.                         $qb->setParameter($field, array_keys($value));
  1035.                     } else {
  1036.                         $qb->andWhere('s.'. $field . ' = :' . $field);
  1037.                         $qb->setParameter($field, $value);
  1038.                     }
  1039.                     break;
  1040.             }
  1041.         }
  1042.         return $qb;
  1043.     }
  1046.     private function expandTimeCriteria($qb, $value)
  1047.     {
  1048.         $startDate = date_create($value);
  1049.         $endDate   = date_create($value);
  1050.         $endDate->modify('+1 days');
  1051.         $qb->andWhere('c.start BETWEEN :startDate AND :endDate')
  1052.             ->setParameter('startDate', $startDate)
  1053.             ->setParameter('endDate', $endDate)
  1054.         ;
  1056.         return $qb;
  1057.     }
  1059.     public function importOrUpdateByApplication(Application $application, User $user, $importTag)
  1060.     {
  1061.         $em = $this->getEntityManager();
  1062.         $now = new DateTime();
  1063.         $adminEmail = $user->getEmail();
  1065.         $status          = 'open';
  1066.         $todo            = '';
  1067.         $responseContent = [];
  1068.         $exportList      = [];
  1069.         $preFields       = [];
  1070.         $responseText    = "Case #{$application->getStartupName()} ";
  1072.         $program = $em->getRepository(Program::class /*Startup Program*/)->findOneBy(['id'=>$application->getProgramId()]);
  1073.         $batch   = $em->getRepository(Batch::class)->findOneBy(['id'=>$application->getBatchId()]);
  1076.         if ($application->getWebsiteUrl()) {
  1077.             $domain = $this->extractDomainByWebsite($application->getWebsiteUrl());
  1078.             if (in_array($domain, $this->getDomainServices())) {
  1079.                 $domain = $application->getWebsiteUrl() ;
  1080.             }
  1082.         } else {
  1083.             $domain = $this->extractDomainByEmail($application->getEmail());
  1084.             if (in_array($domain, $this->getMailServices())) {
  1085.                 $domain = str_replace('@', 'at', $application->getEmail()) ;
  1086.             }
  1087.         }
  1089.         // check if application->teamId is virtual team
  1090.         if ($teamId = $application->getTeamId()) {
  1091.             if (!$team = $em->getRepository(Team::class)->find($teamId)) {
  1092.                 $teamId = "";
  1093.             } else {
  1094.                 if ($team->getType() == 'Virtual Team') {
  1095.                     $teamId = "";
  1096.                 }
  1097.             }
  1098.         }
  1100.         // check if startup is already imported
  1101.         if (!$startup = $this->findOneBy(['id' => $application->getStartupId()])) {
  1102.             // check if there is already a startup with the application teamId
  1103.             if (!$startup = $this->findOneBy(['teamId'=>$application->getTeamId()])) {
  1104.                 // lookup domain
  1105.                 if ($startup = $this->findOneBy(['domain'=>$domain])) {
  1106.                     $response = [
  1107.                         'status'  => "ERROR",
  1108.                         'todo'    => "checkDomain",
  1109.                         'message' => "Domain {$domain} is already stored with startup {$startup->getName()} [{$startup->getId()}] ",
  1110.                         'data'    => $startup,
  1111.                     ];
  1113.                     return $response;
  1115.                 } elseif ($startup = $this->findOneBy(['teamId' => $team->getId()])) {
  1116.                     $response = [
  1117.                         'status'  => "ERROR",
  1118.                         'todo'    => "checkTeamId",
  1119.                         'message' => "teamId {$teamId} is already stored with startup {$startup->getName()} [{$startup->getId()}] ",
  1120.                         'data'    => $startup,
  1121.                     ];
  1123.                     return $response;
  1125.                 } else {
  1126.                     $startup = new Startup();
  1128.                     $startup->setTeamId($teamId);
  1129.                     $startup->setDomain($domain);
  1130.                     // UP-024: setStartplatz removed - no longer tracked on Startup
  1131.                 }
  1132.             }
  1133.         }
  1135.         if ($startup->getId()) {
  1136.             $responseText .= "updated on ";
  1137.         } else {
  1138.             $responseText .= "imported ";
  1139.         }
  1141.         $startup->setName($application->getStartupName());
  1142.         if ($startup->getName() and !$startup->getSlug()) {
  1143.             $startup = $this->updateSlugByStartupName($startup);
  1144.         }
  1146.         $startup->setStatus('active');
  1148.         // UP-024: Rheinland-Pitch data now managed via Participation entity
  1149.         // setOrUpdateRheinlandPitchSpecials and pitchNumber/pitchDate/pitchTopic removed
  1150.         // Use ParticipationOutcomeWriter::recordRheinlandPitchOutcome() for outcomes
  1152.         $startup->setWebsite($this->sanitizeWebsite($application->getWebsiteUrl()));
  1153.         $startup->setCity($application->getCity());
  1154.         $startup->setEmployeesCount($application->getTeamSize());
  1155.         $startup->setStage($application->getStartupStage());
  1157.         $startup->setContactPerson($application->getPerson());
  1158.         $startup->setContactEmail($application->getEmail());
  1159.         $startup->setContactTelefon($this->sanitizePhone($application->getPhone()));
  1160.         $startup->setLinkedin($application->getLinkedin());
  1162.         $startup->setOneSentencePitch($this->sanitizeDescription($application->getIdeaPitch()));
  1164.         $startup->setVisibility($this->setVisibilityByApplicationProgramStatus($application, $startup->getVisibility()));
  1166.         $startup->setLastChangedBy($adminEmail);
  1168.         $em->persist($startup);
  1169.         $em->flush();
  1171.         $responseText .= "application has been imported";
  1173.         if (!$startupAttribute = $em->getRepository(StartupAttribute::class)->findOneBy(['startupId'=> $startup->getId(), 'teamId'=>$user->getMemberId()])) {
  1174.             $startupAttribute = new StartupAttribute();
  1175.             $startupAttribute->setTeamId($user->getMemberId());
  1176.             $startupAttribute->setStartupId($startup->getId());
  1177.         }
  1179.         $startupAttribute->setTeamTags($em->getRepository(Tag::class)->addHashTag($importTag, $startupAttribute->getTeamTags()));
  1181.         $startupAttribute->setLastModified($now);
  1182.         $startupAttribute->setLastChangedBy($adminEmail);
  1183.         $em->persist($startupAttribute);
  1184.         $em->flush();
  1186.         $em->getRepository(StartupRelevance::class)->updateByUserAction($startup->getId(), 'create');
  1188.         if (!$application->getStartupId()) {
  1190.             $application->setStartupId($startup->getId());
  1191.             $application->setEditStatus('imported in startup table');
  1192.             $responseText .= " startupId has been set in application";
  1193.         } else {
  1194.             $application->setEditStatus('updated in startup table');
  1195.             $responseText .= " updated in startup table";
  1197.         }
  1198.         $em->persist($application);
  1199.         $em->flush();
  1201.         // check if startupId need to be set in table team
  1202.         if ($startup->getTeamId() > 0) {
  1203.             $em->getRepository(Team::class)->setStartupIdIfNotExists($startup->getTeamId(), $startup->getId(), $adminEmail);
  1204.         }
  1206.         $responseContent[] = $responseText . " done";
  1208.         $response = [
  1209.             'status'  => "SUCCESS",
  1210.             'todo'    => "done",
  1211.             'message' => $responseContent,
  1212.             'data'    => $startup,
  1213.         ];
  1216.         return $response;
  1217.     }
  1219.     /**
  1220.      * @deprecated UP-024: Removed - Rheinland-Pitch data now managed via Participation entity
  1221.      * Use ParticipationOutcomeWriter::recordRheinlandPitchOutcome() instead
  1222.      */
  1223.     public function setOrUpdateRheinlandPitchSpecials(Startup $startup, Application $application)
  1224.     {
  1225.         // UP-024: This method is now a no-op
  1226.         // Rheinland-Pitch participation and outcomes are stored in sp_ecosystem_participation
  1227.         // See ParticipationOutcomeWriter::recordRheinlandPitchOutcome()
  1228.         return $startup;
  1229.     }
  1231.     private function setVisibilityByApplicationProgramStatus(Application $application, $currentVisibility)
  1232.     {
  1233.         switch ($application->getBatchStatus()) {
  1234.             case "pitch":
  1235.                 return "public";
  1236.             case "pre pitch":
  1237.                 if ($currentVisibility != "public") {
  1238.                     return "sp-connect";
  1239.                 } else {
  1240.                     return $currentVisibility;
  1241.                 }
  1242.                 // no break
  1243.             case "applicant":
  1244.                 if (!$currentVisibility) {
  1245.                     return "admin";
  1246.                 } else {
  1247.                     return $currentVisibility;
  1248.                 }
  1250.         }
  1251.     }
  1253.     public function importOrUpdateByTeam(Team $team, $user = false, $importTag = false)
  1254.     {
  1255.         $em = $this->getEntityManager();
  1256.         $now = new DateTime();
  1257.         if ($user) {
  1258.             $adminEmail = $user->getEmail();
  1259.         } else {
  1260.             $adminEmail = "system@";
  1261.         }
  1264.         if (!$team->getCategories()){
  1265.             $team = $em->getRepository(Team::class)->setCategory($team, "startup", $adminEmail);
  1266.         }
  1268.         $todos           = [];
  1269.         $responseText    = "Case #{$team->getName()} ";
  1270.         $teamCategories  = explode(',', str_replace(' ', '', $team->getCategories() ?? ''));
  1271.         $teamTags        = array_filter(explode('#', str_replace(' ', '', $team->getTags() ?? '')));
  1274.         // check if startup is already imported
  1275.         if (!$startup = $this->findOneBy(['teamId' => $team->getId()])) {
  1276.             $startup = new Startup();
  1277.             $startup->setTeamId($team->getId());
  1278.             $startup->setStatus('active');
  1279.             $startup->setCreatedAt($now);
  1280.         }
  1282.         $tags = $startup->getTags();
  1284.         if (!$startup->getWebsite()) {
  1285.             if (!$team->getHomepage()) {
  1286.                 $todos[] = "check homepage";
  1287.             } else {
  1288.                 $domain = $this->cleanDomain($team->getHomepage());
  1289.                 $startup->setDomain($domain);
  1290.                 $startup->setWebsite($this->sanitizeWebsite($team->getHomepage()));
  1291.             }
  1292.         }
  1294.         if ($startup->getId()) {
  1295.             $responseText .= "updated on ";
  1296.         } else {
  1297.             $responseText .= "imported ";
  1298.         }
  1300.         if (!$startup->getName()) {
  1301.             $startup->setName($team->getName());
  1302.             if ($startup->getName() and !$startup->getSlug()) {
  1303.                 $startup = $this->updateSlugByStartupName($startup);
  1304.             }
  1305.         }
  1307.         // UP-024: Program-specific fields removed from Startup
  1308.         // startplatz, gruenderstipendium, gsJury, gsStatus, accelerator, batch, batchYear
  1309.         // are now managed via Participation entity
  1311.         if ($team->getGsStatus()) {
  1312.             $tags = $em->getRepository(Tag::class)->addHashTag('gruenderstipendium', $tags);
  1313.             $tags = $em->getRepository(Tag::class)->addHashTag('sp-connect', $tags);
  1314.         }
  1316.         if (in_array('accelerator', $teamCategories)) {
  1317.             $tags = $em->getRepository(Tag::class)->addHashTag('accelerator', $tags);
  1318.             $tags = $em->getRepository(Tag::class)->addHashTag('sp-connect', $tags);
  1319.         }
  1321.         if (!$startup->getCity()) {
  1322.             $startup->setCity($team->getAddressCity());
  1323.         }
  1325.         if (!$startup->getEmployeesCount()) {
  1326.             $startup->setEmployeesCount($team->getNEmployees());
  1327.         }
  1329.         if (!$startup->getContactPerson()) {
  1330.             $startup->setContactPerson($team->getPerson());
  1331.         }
  1333.         if(!$startup->getLogoUrl() and $team->getLogoUrl()) {
  1334.             $startup->setLogoUrl($team->getLogoURL());
  1335.         }
  1337.         if (!$startup->getContactEmail()) {
  1338.             $startup->setContactEmail($team->getConnectEmail());
  1339.         }
  1341.         if (!$startup->getContactTelefon()) {
  1342.             $startup->setContactTelefon($team->getPhone());
  1343.         }
  1346.         if (!$startup->getStage()) {
  1347.             $startup->setStage('idea');
  1348.         }
  1349.         if (!$startup->getCustomerFocus()) {
  1350.             $startup->setCustomerFocus('B2B');
  1351.         }
  1353.         if (!$startup->getIndustry()) {
  1354.             $startup->setIndustry($team->getIndustries());
  1355.         }
  1357.         $startup->setTags($tags);
  1359.         if (!$startup->getOneSentencePitch()) {
  1360.             $startup->setOneSentencePitch($this->sanitizeDescription($team->getDescription()));
  1361.         }
  1363.         $startup->setLastChangedBy($adminEmail);
  1365.         $startup->setTodos(implode(',', $todos));
  1367.         $startup->setLastModified($now);
  1369.         $em->persist($startup);
  1370.         $em->flush();
  1372.         $responseText .= "application has been imported";
  1374.         if ($user and $importTag) {
  1375.             if (!$startupAttribute = $em->getRepository(StartupAttribute::class)->findOneBy(['startupId'=> $startup->getId(), 'teamId'=>$user->getMemberId()])) {
  1376.                 $startupAttribute = new StartupAttribute();
  1377.                 $startupAttribute->setTeamId($user->getMemberId());
  1378.                 $startupAttribute->setStartupId($startup->getId());
  1379.             }
  1381.             $startupAttribute->setTeamTags($em->getRepository(Tag::class)->addHashTag($importTag, $startupAttribute->getTeamTags()));
  1383.             $startupAttribute->setLastModified($now);
  1384.             $startupAttribute->setLastChangedBy($adminEmail);
  1385.             $em->persist($startupAttribute);
  1386.             $em->flush();
  1388.             $em->getRepository(StartupRelevance::class)->updateByUserAction($startup->getId(), 'create');
  1389.         }
  1391.         if (!$team->getStartupId()) {
  1392.             $team = $em->getRepository(Team::class)->setStartupId($team, $startup->getId(), $adminEmail);
  1393.             $responseText .= " startupId has been set in team";
  1394.         }
  1396.         $responseText .= " done";
  1399.         return $responseText;
  1400.     }
  1403.     public function updateWebsiteByTeamHomepage(Startup $startup, $homepage)
  1404.     {
  1405.         $domain = $this->cleanDomain($homepage);
  1406.         $startup->setDomain($domain);
  1407.         $startup->setWebsite($this->sanitizeWebsite($homepage));
  1408.         return $startup;
  1409.     }
  1411.     public function syncDataWithTeam(Startup $startup, Team $team)
  1412.     {
  1413.         $update = false;
  1414.         if ($team->getShortName() and $startup->getName() != $team->getShortName()) {
  1415.             $startup->setName($team->getShortName());
  1416.             $update = true;
  1417.         }
  1419.         if ($team->getLogoURL() and $startup->getLogoUrl() != $team->getLogoURL()) {
  1420.             $startup->setLogoUrl($team->getLogoURL());
  1421.             $update = true;
  1422.         }
  1424.         if ($team->getHomepage() and $startup->getWebsite() != $team->getHomepage()) {
  1425.             $startup = $this->updateWebsiteByTeamHomepage($startup, $team->getHomepage());
  1426.             $update = true;
  1427.         }
  1429.         if ($team->getLinkedin() and $startup->getLinkedin() != $team->getLinkedin()) {
  1430.             $startup->setLinkedin($team->getLinkedin());
  1431.             $update = true;
  1432.         }
  1434.         if ($team->getXing() and $startup->getXing() != $team->getXing()) {
  1435.             $startup->setXing($team->getXing());
  1436.             $update = true;
  1437.         }
  1438.         if ($team->getTwitter() and $startup->getTwitter() != $team->getTwitter()) {
  1439.             $startup->setTwitter($team->getTwitter());
  1440.             $update = true;
  1441.         }
  1442.         if ($team->getFacebook() and $startup->getFacebook() != $team->getFacebook()) {
  1443.             $startup->setFacebook($team->getFacebook());
  1444.             $update = true;
  1445.         }
  1446.         if ($team->getInstagram() and $startup->getInstagram() != $team->getInstagram()) {
  1447.             $startup->setInstagram($team->getInstagram());
  1448.             $update = true;
  1449.         }
  1451.         if ($update) {
  1452.             $startup->setScore($this->setStartupCompletenessScore($startup));
  1454.             $em = $this->getEntityManager();
  1455.             $em->persist($startup);
  1456.             $em->flush();
  1457.         }
  1458.         return $startup;
  1459.     }
  1462.     public function updateSlugByStartupName(Startup $startup)
  1463.     {
  1464.         $slug = Utility::generateSlug($startup->getName());
  1465.         if ($startup->getSlug() != $slug) {
  1466.             $connection = $this->getEntityManager()->getConnection();
  1467.             $oldSlug = $startup->getSlug();
  1468.             if ($oldSlug != null) {
  1469.                 // replace old slug with new slug
  1470.                 // in memberPosts
  1471.                 $sql = "
  1472.                 UPDATE sp_content_posts 
  1473.                 SET tags = REPLACE(tags,:oldSlug,:slug)
  1474.                 WHERE tags LIKE :queryString
  1475.             ";
  1476.                 $connection->executeQuery($sql, ['oldSlug'=>$oldSlug, 'slug'=>$slug, 'queryString' => '%'.$oldSlug.'%']);
  1477.                 // in feeds
  1478.                 $sql = "
  1479.                 UPDATE sp_content_feed
  1480.                 SET tags = REPLACE(tags,:oldSlug,:slug)
  1481.                 WHERE tags LIKE :queryString
  1482.             ";
  1483.                 $connection->executeQuery($sql, ['oldSlug'=>$oldSlug, 'slug'=>$slug, 'queryString' => '%"'.$oldSlug.'"%']);
  1484.             }
  1485.             $startup->setSlug($slug);
  1486.         }
  1487.         return $startup;
  1488.     }
  1490.     public function updateByEdit(Startup $startup, $differences, $adminEmail)
  1491.     {
  1492.         $em = $this->getEntityManager();
  1493.         if ($differences) {
  1494.             foreach ($differences as $diff => $value) {
  1495.                 switch ($diff) {
  1496.                     case "id":
  1497.                         break;
  1498.                     case "website":
  1499.                         $startup->setWebsite(rtrim((string) $value, "/"));
  1501.                         $domain = $this->cleanDomain($startup->getWebsite());
  1502.                         if ($startup->getDomain() != $domain) {
  1503.                             $startup->setDomain($domain);
  1504.                         }
  1505.                         break;
  1506.                     default:
  1507.                         $method = 'set' . ucfirst((string) $diff);
  1508.                         $startup->$method($value);
  1509.                         break;
  1510.                 }
  1511.             }
  1513.             $startup->setScore($this->setStartupCompletenessScore($startup));
  1515.             $startup->setLastChangedBy($adminEmail);
  1517.             $em->persist($startup);
  1518.             $em->flush();
  1519.         }
  1520.         return $startup;
  1521.     }
  1523.     public function setComments(Startup $startup, $addNote, $adminEmail)
  1524.     {
  1525.         $em = $this->getEntityManager();
  1527.         $startup->setLastChangeUser($adminEmail);
  1529.         $startup->setComments('==== '. date("Y-m-d") . ' by ' . $startup->getLastChangeUser() .' ==='. PHP_EOL . $addNote   . PHP_EOL . $startup->getComments());
  1531.         $logText = "added Comment";
  1532.         $startup->setHistory('==== '. date("Y-m-d") . ' by ' . $startup->getLastChangeUser() .' ==='. PHP_EOL . $logText   . PHP_EOL . $startup->getHistory());
  1534.         $em->persist($startup);
  1535.         $em->flush();
  1537.         return $startup;
  1538.     }
  1540.     public function importOrUpdate($feedback, $fields, User $user, $template, $importTag)
  1541.     {
  1542.         $em = $this->getEntityManager();
  1543.         $now = new DateTime();
  1544.         $adminEmail = $user->getEmail();
  1546.         $responseContent = [];
  1547.         $exportList      = [];
  1548.         $preFields       = [];
  1550.         $j = 0;
  1551.         foreach($feedback as $row) {
  1552.             $j++;
  1553.             $responseText = "Case #{$j} ";
  1555.             // check if array in row contains as many elements as fields
  1556.             if ((is_countable($fields) ? count($fields) : 0) != (is_countable($row) ? count($row) : 0)) {
  1557.                 $i = 0;
  1558.                 foreach ($fields as $field) {
  1559.                     $newRow[ $field ] = $row[$i] ?? '' ;
  1560.                     $i++;
  1561.                 }
  1562.                 $row = $newRow;
  1563.             } else {
  1564.                 $row = array_combine($fields, $row);
  1565.             }
  1568.             if (array_key_exists('action', $row) and  $row['action'] == 'checkUrl') {
  1569.                 $preData = [
  1570.                     'sp_id'      => '99999',
  1571.                     'sp_teamId'  => '77777',
  1572.                     'sp_name'    => 'n.a.',
  1573.                     'sp_website' => 'n.a.',
  1574.                 ];
  1575.                 $preFields = array_keys($preData);
  1578.                 if (!$row['website']) {
  1579.                     $exportList[] = implode("\t", array_merge($preData, $row));
  1580.                     continue;
  1581.                 }
  1582.                 $domain = $this->cleanDomain($row['website']);
  1584.                 if ($startup = $this->findOneByLike('domain', $domain)) {
  1585.                     $preData = [
  1586.                         'sp_id'      => $startup->getId(),
  1587.                         'sp_teamId'  => $startup->getTeamId(),
  1588.                         'sp_name'    => $startup->getName(),
  1589.                         'sp_website' => $startup->getWebsite(),
  1590.                     ];
  1591.                 }
  1593.                 $exportList[] = implode("\t", array_merge($preData, $row));
  1594.                 continue;
  1595.             }
  1597.             if (array_key_exists('action', $row)) {
  1598.                 $stopProcessing = false;
  1599.                 switch ($row['action']) {
  1600.                     case "addApplication":
  1601.                         $responseContent[] = $this->importAddApplication($row, $fields, $adminEmail);
  1602.                         $stopProcessing = true;
  1603.                         break;
  1604.                     case "delete":
  1605.                         $em->remove($startup);
  1606.                         $em->flush();
  1607.                         $responseContent[] = $responseText . " entry permanently removed";
  1608.                         $stopProcessing = true;
  1609.                         break;
  1610.                 }
  1612.                 if ($stopProcessing) {
  1613.                     continue; // go to next iteration in loop
  1614.                 }
  1615.             }
  1618.             if (!$startup = $this->findOneBy(['id'=>$row['id']])) {
  1619.                 // check if startup is already imported
  1620.                 if (!$startup = $this->findAlreadyImportedstartup($row, $template)) {
  1621.                     $startup = new Startup();
  1622.                 }
  1623.             } else {
  1624.                 $responseText .= "{$startup->getId()} ";
  1625.             }
  1628.             if (in_array('phone', array_keys($row)) or in_array('website', array_keys($row)) or in_array('segment', array_keys($row))) {
  1629.                 $row = $this->sanitizeRowData($row);
  1630.             }
  1632.             // get rid of elements with empty value
  1633.             // $row = array_filter($row);
  1634.             $startupData = $this->fillEntityData($startup, $fields);
  1636.             if ($startup->getImportNote() == 'foundByDomain') {
  1637.                 if (array_key_exists('overwrite', $row) and $row['overwrite'] == 'yes') {
  1638.                     $responseText .= "content will be overwritten ";
  1639.                 } else {
  1640.                     $exportList[] = implode("\t", $startupData + ['overwrite' => 'no']) ;
  1641.                     $exportList[] = implode("\t", $this->fillRow($row, $fields) + ['overwrite' => 'no']);
  1642.                     $responseContent[] = $responseText . "no import - foundByDomain";
  1643.                     continue;
  1644.                 }
  1645.                 $startup->setImportNote('');
  1646.             }
  1648.             $differences = array_diff($row, $startupData);
  1649.             $differences2 = array_diff($startupData, $row);
  1650.             $differences = $differences + $differences2;
  1652.             if ($differences) {
  1653.                 if ($startup->getId()) {
  1654.                     $responseText .= "updated on ";
  1655.                 } else {
  1656.                     $responseText .= "imported ";
  1657.                 }
  1659.                 foreach ($differences as $diff => $value) {
  1660.                     switch ($diff) {
  1661.                         case "id":
  1662.                             break;
  1663.                         case "action":
  1664.                             if ($row['action'] == 'checkLogo') {
  1665.                                 $startup = $this->checkLogo($startup);
  1666.                                 if ($startup->getImportNote() and $startup->getImportNote() != "Bad Request") {
  1667.                                     $suggestions = json_decode((string) $startup->getImportNote());
  1669.                                     $exportParts = '';
  1670.                                     $exportPartsArray = [];
  1671.                                     foreach ($suggestions as  $suggestion) {
  1672.                                         $columns = array_values((array) $suggestion);
  1673.                                         $exportPartsArray = [...$exportPartsArray, ...$columns];
  1674.                                     }
  1675.                                     $exportList[] = implode("\t", $this->fillRow($row, $fields) + $exportPartsArray);
  1676.                                     $startup->setImportNote('');
  1677.                                 }
  1678.                             }
  1679.                             break;
  1680.                         case "website":
  1681.                             $startup->setWebsite(rtrim((string) $row['website'], "/"));
  1683.                             $domain = $this->cleanDomain($startup->getWebsite());
  1684.                             if ($startup->getDomain() != $domain) {
  1685.                                 $startup->setDomain($domain);
  1686.                             }
  1687.                             break;
  1688.                         case "domain":
  1689.                             if (!$domain = $row['domain']) {
  1690.                                 if (array_key_exists('website', $row)) {
  1691.                                     $domain = $this->cleanDomain($row['website']);
  1692.                                 }
  1693.                             }
  1694.                             $startup->setDomain($domain);
  1695.                             break;
  1696.                         case "pitchNumber":
  1697.                             // UP-024: pitchNumber field removed - creating application only
  1698.                             $program = $em->getRepository(Program::class /*Startup Program*/)->findOneBy(['id'=>1]);
  1699.                             $em->persist($startup);
  1700.                             $em->flush();
  1701.                             $startupArray['id'] = $startup->getId();
  1702.                             $responseText .=  $em->getRepository(Application::class)->createApplicationByStartup($startupArray, $program, $adminEmail);
  1703.                             break;
  1704.                         case "todos":
  1705.                             $todosArrayStored = [];
  1706.                             if ($startup->getTodos()) {
  1707.                                 $todosArrayStored = json_decode((string) $startup->getTodos(), true);
  1708.                             }
  1709.                             $todosArrayImported = explode(',', str_replace(', ', ',', (string) $row['todos']));
  1710.                             $todosArray = array_merge($todosArrayImported, $todosArrayStored);
  1712.                             array_filter($todosArray);
  1713.                             $todosArray = array_unique($todosArray);
  1714.                             $todosJson = json_encode(array_values($todosArray));
  1716.                             $startup->setTodos($todosJson);
  1717.                             break;
  1718.                         case "tags":
  1719.                             $startup->setTags($em->getRepository(Tag::class)->updateHashTags($row['tags'], $startup->getTags()));
  1720.                             break;
  1721.                         case "status":
  1722.                             $startup->setStatus($row['status'] ?: 'unknown');
  1723.                             break;
  1724.                         case "startplatz":
  1725.                         case "batch":
  1726.                         case "batchLast":
  1727.                         case "pitchDate":
  1728.                             // UP-024: These fields removed from Startup - managed via Participation entity
  1729.                             break;
  1730.                         case "city":
  1731.                             if ($row['city'] == 'CGN' or $row['city'] == 'DUS') {
  1732.                                 $startup->setLocation($row['city']);
  1733.                                 if ($row['city'] == 'CGN') {
  1734.                                     $startup->setCity('Köln');
  1735.                                 }
  1736.                                 if ($row['city'] == 'DUS') {
  1737.                                     $startup->setCity('Düsseldorf');
  1738.                                 }
  1739.                             } else {
  1740.                                 $startup->setCity($row['city']);
  1741.                             }
  1742.                             break;
  1743.                         default:
  1744.                             $method = 'set' . ucfirst($diff);
  1745.                             $startup->$method(trim((string) $row[$diff]));
  1746.                             break;
  1747.                     }
  1748.                     $responseText .= " {$diff} with  {$row[$diff]}, ";
  1749.                 }
  1750.                 if ($startup->getWebsite() and !$startup->getDomain()) {
  1751.                     $startup->setDomain($this->cleanDomain($startup->getWebsite()));
  1752.                 }
  1753.                 if ($startup->getName() and !$startup->getSlug()) {
  1754.                     $startup = $this->updateSlugByStartupName($startup);
  1755.                 }
  1756.                 if (!$startup->getStatus()) {
  1757.                     $startup->setStatus('unknown');
  1758.                 }
  1759.                 // UP-024: startplatz, accelerator, rheinlandPitch fields removed
  1760.                 // These are now managed via Participation entity
  1761.                 if (!$startup->getIndustry()) {
  1762.                     $startup->setIndustry('Other');
  1763.                 }
  1764.                 if (!$startup->getIndustryCondensed()) {
  1765.                     $startup->setIndustryCondensed('Other');
  1766.                 }
  1767.                 if (!$startup->getCustomerFocus()) {
  1768.                     $startup->setCustomerFocus('unknown');
  1769.                 }
  1770.                 if (!$startup->getBusinessModel()) {
  1771.                     $startup->setBusinessModel('Other');
  1772.                 }
  1774.                 $startup->setLastChangedBy($adminEmail);
  1776.                 $em->persist($startup);
  1777.                 $em->flush();
  1779.                 // check if teamId
  1780.                 if ($startup->getTeamId()>0) {
  1781.                     $em->getRepository(Team::class)->setStartupIdIfNotExists($startup->getTeamId(), $startup->getId(), $adminEmail);
  1782.                 }
  1783.                 if (!$startupAttribute = $em->getRepository(StartupAttribute::class)->findOneBy(['startupId'=> $startup->getId(), 'teamId'=>$user->getMemberId()])) {
  1784.                     $startupAttribute = new StartupAttribute();
  1785.                     $startupAttribute->setTeamId($user->getMemberId());
  1786.                     $startupAttribute->setStartupId($startup->getId());
  1787.                 }
  1789.                 $em->getRepository(StartupRelevance::class)->updateByUserAction($startup->getId(), 'create');
  1792.                 $startupAttribute->setTeamTags($em->getRepository(Tag::class)->addHashTag($importTag, $startupAttribute->getTeamTags()));
  1794.                 $startupAttribute->setLastModified($now);
  1795.                 $startupAttribute->setLastChangedBy($adminEmail);
  1796.                 $em->persist($startupAttribute);
  1797.                 $em->flush();
  1799.                 $responseContent[] = $responseText . "row has been imported";
  1801.             } else {
  1802.                 $responseContent[] = $responseText . "no update";
  1803.             }
  1805.             //$responseContent[] = $startupData;
  1807.         }
  1808.         return ['responseContent' =>$responseContent, 'exportList' => $exportList, 'preFields' => $preFields];
  1809.     }
  1811.     private function importAddApplication($row, $fields, $adminEmail)
  1812.     {
  1813.         $em = $this->getEntityManager();
  1814.         $now = new \DateTime();
  1816.         $domain  = $this->extractDomainByWebsite($row['website']);
  1817.         $startup = $this->findOrCreateStartupByDomain($domain);
  1818.         $batch   = $em->getRepository(Batch::class)->findOneBy(['programId'=>$row['programId'], 'batchNumber'=>$row['batchNumber']]);
  1819.         /** @var Program $program */
  1820.         $program = $batch->getProgram();
  1821.         $application = $em->getRepository(Application::class)->findOrCreateApplicationByWebsiteUrl($row['website']);
  1823.         if (!$startup->getId()) {
  1824.             $startup->setName($row['name']);
  1825.             $startup->setWebsite($row['website']);
  1826.             $startup->setOneSentencePitch($row['oneSentencePitch']);
  1827.             $startup->setContactEmail($row['email']);
  1828.             $startup->setLastChangedBy($adminEmail);
  1829.             $startup->setCreatedAt($now);
  1830.             $startup->setLastModified($now);
  1832.             $em->persist($startup);
  1833.             $em->flush();
  1834.         }
  1835.         if (!$teamId = $startup->getTeamId()) {
  1836.             // find virtual team of that batch
  1837.             $settings = (array) json_decode((string) $batch->getSettings(), true);
  1838.             $team     = $em->getRepository(Team::class)->findOneBy(['shortName'=>$settings['virtualTeam']]);
  1839.             $teamId   = $team->getId();
  1840.         }
  1841.         $application->setStartupId($startup->getId());
  1842.         $application->setTeamId($teamId);
  1843.         $application->setEmail($row['email']);
  1844.         $application->setStartupName($row['name']);
  1845.         $application->setProgramId($row['programId']);
  1846.         $application->setBatchId($batch->getId());
  1847.         $application->setBatchName($batch->getName());
  1848.         $application->setBatchSlug($batch->getSlug());
  1849.         $application->setTemplate($batch->getTemplate());
  1850.         $application->setProgramSlug($program->getSlug());
  1851.         $application->setProgramName($program->getName());
  1853.         $application->setApplicationStatus('approved');
  1854.         $application->setBatchStatus($row['status']);
  1855.         $application->setIdeaPitch($row['oneSentencePitch']);
  1857.         $application->setLastChangeUser($adminEmail);
  1858.         $application->setCreatedAt($now);
  1859.         $application->setLastModified($now);
  1861.         $em->persist($application);
  1862.         $em->flush();
  1864.         return "application created with id={$application->getId()}";
  1865.     }
  1867.     private function findOrCreateStartupByDomain($domain)
  1868.     {
  1869.         $em = $this->getEntityManager();
  1870.         if (!$startup = $this->findOneBy(['domain'=>$domain])) {
  1871.             $startup = new Startup();
  1873.             $startup->setDomain($domain);
  1874.         }
  1876.         return $startup;
  1877.     }
  1879.     public function setEmptyStartup()
  1880.     {
  1881.         return new Startup();
  1882.     }
  1884.     private function findOneByLike($field, $criterium)
  1885.     {
  1887.         $qb = $this->getEntityManager()->createQueryBuilder();
  1889.         $qb
  1890.             ->select('c')
  1891.             ->from(Startup::class, 'c')
  1892.             ->where("c.{$field} LIKE :{$field}")
  1893.             ->setParameter($field, "%{$criterium}%")
  1894.             ->setMaxResults(1)
  1895.             ->orderBy('c.lastModified', 'DESC')
  1896.         ;
  1898.         return $qb->getQuery()->getOneOrNullResult();
  1899.     }
  1901.     private function fillRow($row, $fields)
  1902.     {
  1903.         foreach ($fields as $field) {
  1904.             $oldData[$field] =  array_key_exists($field, $row) ? $row[$field] : '' ;
  1905.         }
  1906.         return $oldData;
  1907.     }
  1909.     private function fillEntityData($entity, $fields)
  1910.     {
  1911.         foreach ($fields as $field) {
  1912.             $method = 'get' . ucfirst((string) $field);
  1913.             if ($entity->$method() instanceof DateTime) {
  1914.                 $oldData[$field] = $entity->$method()->format('Y-m-d') ;
  1915.             } elseif (in_array($field, ['todos'])) {
  1916.                 if ($entity->$method()) {
  1917.                     $oldData[$field] = implode(',', json_decode((string) $entity->$method(), true));
  1918.                 } else {
  1919.                     $oldData[$field] = '';
  1920.                 }
  1921.             } else {
  1922.                 $oldData[$field] = trim((string) $entity->$method());
  1923.             }
  1924.             // UP-024: Removed 'startplatz' and 'accelerator' - fields no longer exist
  1925.             if (in_array($field, ['status']) and !$oldData[$field]) {
  1926.                 $oldData[$field] = 'default';
  1927.             }
  1928.         }
  1930.         return $oldData;
  1931.     }
  1933.     private function sanitizeRowData($row)
  1934.     {
  1935.         if (in_array('phone', array_keys($row))) {
  1936.             $row['phone'] = $this->sanitizePhone($row['phone']);
  1937.         }
  1938.         if (in_array('website', array_keys($row)) and $row['website']) {
  1939.             $row['website'] = $this->sanitizeWebsite($row['website']);
  1940.         }
  1941.         if (in_array('todos', array_keys($row)) and $row['todos']) {
  1942.             $row['todos'] = str_replace(', ', ',', (string) $row['todos']);
  1943.         }
  1944.         if (in_array('segment', array_keys($row))) {
  1945.             $row['segment'] = $this->sanitizeSegment($row['segment']);
  1946.         }
  1947.         return $row;
  1948.     }
  1950.     private function sanitizeWebsite($website)
  1951.     {
  1952.         $website = strtolower((string) $website);
  1953.         if (!(str_starts_with($website, 'https://') or str_starts_with($website, 'http://'))) {
  1954.             $website = 'https://' . $website;
  1955.         }
  1956.         $website = str_replace('http://', 'https://', $website);
  1957.         return $website;
  1958.     }
  1960.     private function sanitizePhone($phone)
  1961.     {
  1962.         $phone = str_replace('+49 (0) ', '+49-', (string) $phone);
  1963.         $phone = str_replace('+49 ', '+49-', $phone);
  1965.         $phone = str_replace('/', '-', $phone);
  1966.         $phone = str_replace('(', '', $phone);
  1967.         $phone = str_replace(') ', '-', $phone);
  1968.         $phone = str_replace(' ', '', $phone);
  1970.         if (substr((string) $phone, 0, 1) === 0) {
  1971.             $phone = '+49-' . substr((string) $phone, 1);
  1972.         }
  1973.         if (str_starts_with($phone, '49')) {
  1974.             $phone = '+' . $phone;
  1975.         }
  1976.         if (substr((string) $phone, 3, 1) !== '-') {
  1977.             $phone = substr((string) $phone, 0, 3) . '-' . substr((string) $phone, 3);
  1978.         }
  1980.         return $phone;
  1981.     }
  1983.     private function sanitizeDescription($description)
  1984.     {
  1985.         $string = str_replace("\r\n", "<br>", (string) $description);
  1987.         $string = str_replace("\r", "", $string);
  1988.         $string = str_replace("\t", "", $string);
  1989.         $string = str_replace("\n", "", $string);
  1991.         $string = str_replace("<p>", "", $string);
  1992.         $string = str_replace("</p>", "", $string);
  1994.         return $string;
  1995.     }
  1997.     private function findAlreadyImportedStartup($row, $template)
  1998.     {
  1999.         $startup = null;
  2000.         switch ($template) {
  2001.             case "ddw":
  2002.                 if (!$startup = $this->findOneBy(['ddwId'=>$row['ddwId']])) {
  2003.                     if ($startup = $this->findByWebsite($row['website'])) {
  2004.                         $startup->setImportNote('foundByWebsite');
  2005.                     }
  2006.                 }
  2007.                 break;
  2008.             case "bizcover":
  2009.                 if (!$startup = $this->findByRegister($row['registerGericht'], $row['registerNumber'])) {
  2010.                     $startup = $this->findByWebsite($row['website']);
  2011.                     if ($startup and $startup->getRegisterGericht()) {
  2012.                         $startup = null;
  2013.                     } else {
  2014.                         $startup->setImportNote('foundByWebsite');
  2015.                     }
  2016.                 }
  2017.                 break;
  2018.             case "default":
  2019.                 if (array_key_exists('extId', $row)) {
  2020.                     if ($startup = $this->findOneBy(['extId'=>$row['extId']])) {
  2021.                         $startup->setImportNote('foundByExtId');
  2022.                         break;
  2023.                     }
  2024.                 }
  2026.                 // check if domain is set
  2027.                 if (array_key_exists('domain', $row)) {
  2028.                     if (!$domain = $row['domain']) {
  2029.                         if (array_key_exists('website', $row) and $row['website']) {
  2030.                             $domain = $this->cleanDomain($row['website']);
  2031.                         }
  2032.                     }
  2033.                     if ($startup = $this->findOneBy(['domain'=>$domain])) {
  2034.                         $startup->setImportNote('foundByDomain');
  2035.                     }
  2036.                 }
  2037.                 break;
  2038.         }
  2040.         return $startup;
  2041.     }
  2043.     private function setSlug($name)
  2044.     {
  2045.         return Utility::generateSlug($name);
  2046.     }
  2048.     private function cleanDomain($website)
  2049.     {
  2050.         $website = str_replace("https://www.", "", (string) $website);
  2051.         $website = str_replace("http://www.", "", $website);
  2052.         $website = str_replace("https://", "", $website);
  2053.         $website = str_replace("http://", "", $website);
  2054.         $website = explode('/', $website)[0];
  2055.         return $website;
  2056.     }
  2058.     private function extractDomainByWebsite($website)
  2059.     {
  2060.         return $this->cleanDomain($website);
  2061.     }
  2063.     private function extractDomainByEmail($email)
  2064.     {
  2065.         return explode('@', (string) $email)[1];
  2066.     }
  2068.     private function getMailServices()
  2069.     {
  2070.         return [
  2071.             "aol.com",
  2072.             "aol.de",
  2073.             "arcor.de",
  2074.             "gmail.com",
  2075.             "gmx.de",
  2076.             "gmx.net",
  2077.             "googlemail.com",
  2078.             "hotmail.com",
  2079.             "hotmail.de",
  2080.             "icloud.com",
  2081.             "mailbox.org",
  2082.             "me.com",
  2083.             "outlook.de",
  2084.             "posteo.de",
  2085.             "yahoo.de",
  2086.         ];
  2087.     }
  2088.     private function getDomainServices()
  2089.     {
  2090.         return [
  2091.             "linkedin.com",
  2092.             "linkedin.de",
  2093.             "facebook",
  2094.         ];
  2095.     }
  2097.     public function updateLogo($startup): void
  2098.     {
  2099.         $startup = $this->checkLogo($startup);
  2100.         if ($startup->getImportNote()) {
  2101.             $suggestions = json_decode((string) $startup->getImportNote());
  2103.             $exportParts = '';
  2104.             $exportPartsArray = [];
  2105.             foreach ($suggestions as  $suggestion) {
  2106.                 $columns = array_values((array) $suggestion);
  2107.                 $exportPartsArray = [...$exportPartsArray, ...$columns];
  2108.             }
  2109.             $exportList[] = implode("\t", $exportPartsArray);
  2110.         }
  2112.     }
  2114.     private function checkLogo(Startup $startup)
  2115.     {
  2116.         $url = "https://autocomplete.clearbit.com/v1/companies/suggest?query={$startup->getName()}";
  2117.         if (!$result = $this->curl_get($url)) {
  2118.             $domain = str_replace('https://', '', $startup->getWebsite());
  2119.             $domain = str_replace('www.', '', $domain);
  2120.             $domain = explode("/", $domain)[0];
  2121.             $url = "https://autocomplete.clearbit.com/v1/companies/suggest?query={$domain}";
  2122.             $result = $this->curl_get($url);
  2123.         }
  2124.         if ($result) {
  2125.             $startup->setImportNote($result);
  2126.         }
  2127.         return $startup;
  2128.     }
  2130.     private function checkDomain(Startup $startup, $row)
  2131.     {
  2132.         $url = "https://autocomplete.clearbit.com/v1/companies/suggest?query={$row['domain']}";
  2133.         if ($result = $this->curl_get($url)) {
  2134.             $startup->setImportNote($result);
  2135.         }
  2136.         return $startup;
  2137.     }
  2139.     public function curl_get($Url, $login = false)
  2140.     {
  2141.         // is cURL installed yet?
  2142.         if (!function_exists('curl_init')) {
  2143.             die('Sorry cURL is not installed!');
  2144.         }
  2145.         // OK cool - then let's create a new cURL resource handle
  2146.         $ch = curl_init();
  2149.         // Set URL to call back
  2150.         curl_setopt($ch, CURLOPT_URL, $Url);
  2152.         // Should cURL return or print out the data? (true = return, false = print)
  2153.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  2155.         $headers = ['Content-Type:application/json'];
  2156.         curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  2158.         // Download the given URL, and return output
  2159.         $output = curl_exec($ch);
  2161.         // Close the cURL resource, and free system resources
  2162.         curl_close($ch);
  2164.         return $output;
  2165.     }
  2167.     public function getTemplateVars($request)
  2168.     {
  2169.         $templateVars = ['filter'  => null, 'tag'     => []];
  2170.         if ($tag = $request->query->get('tag')) {
  2171.             $templateVars['tag'] = trim((string) $tag);
  2172.         }
  2173.         if ($location = $request->query->get('location')) {
  2174.             $templateVars['location']   = $location;
  2175.         }
  2176.         if ($status = $request->query->get('status')) {
  2177.             $status = (!in_array($status, ['active', 'inactive']) ? 'active' : $status);
  2178.             $templateVars['status']   = $status;
  2179.         }
  2180.         if ($criteria = $request->query->get('criteria')) {
  2181.             $templateVars['criteria'] = $criteria;
  2182.         } else {
  2183.             $templateVars['criteria'] = [];
  2184.         }
  2185.         if ($dimensions = $request->query->get('dimension')) {
  2186.             $templateVars['dimensions'] = $dimensions;
  2187.         } else {
  2188.             $templateVars['dimensions'] = [];
  2189.         }
  2190.         if ($filter = $request->query->get('filter') and !$page = $request->get('page')) {
  2191.             $templateVars['filter']   = $filter;
  2192.             if (preg_match("/:/", (string) $filter)) {
  2193.                 $parameters = explode(':', (string) $filter);
  2194.                 if (isset($templateVars['criteria']['id'])) {
  2195.                     unset($templateVars['criteria']['id']);
  2196.                 }
  2197.                 if ($parameters[0] == 'isBookmarked') {
  2198.                     $templateVars['criteria'] = [];
  2199.                 }
  2201.                 if (isset($templateVars['criteria'][$parameters[0]]) and $templateVars['criteria'][$parameters[0]] == $parameters[1]) {
  2202.                     unset($templateVars['criteria'][$parameters[0]]);
  2203.                 } else {
  2204.                     $templateVars['criteria'][$parameters[0]] = $parameters[1];
  2205.                     $templateVars['filter']   = null;
  2206.                 }
  2207.             } else {
  2208.                 if ($filter == 'none') {
  2209.                     $templateVars['criteria'] = [];
  2210.                     $templateVars['filter']   = null;
  2211.                 } else {
  2212.                     $templateVars['filter']   = null;
  2213.                 }
  2214.             }
  2215.         }
  2216.         if ($sort = $request->query->get('sort')) {
  2217.             $templateVars['sort']   = $sort;
  2218.             if (preg_match("/:/", (string) $sort)) {
  2219.                 $parameters = explode(':', (string) $sort);
  2220.                 $templateVars['dimensions'][$parameters[0]] = $parameters[1];
  2221.             } else {
  2222.                 $sort = 'none';
  2223.                 switch ($sort) {
  2224.                     default:
  2225.                         $templateVars['dimensions'] = [];
  2226.                         $templateVars['sort']   = null;
  2227.                         break;
  2228.                 }
  2229.             }
  2230.         }
  2231.         if ($fields = $request->query->get('fields')) {
  2232.             $templateVars['fields']   = $fields;
  2233.         }
  2235.         return $templateVars;
  2236.     }
  2238.     public function getAggregateByGroup($group, $criteria, $order = [], $exact = false)
  2239.     {
  2240.         if (empty($group)) {
  2241.             return [];
  2242.         }
  2244.         // UP-024: Validate field exists before querying to prevent QueryException
  2245.         $metadata = $this->getClassMetadata();
  2246.         if (!$metadata->hasField($group)) {
  2247.             return [];
  2248.         }
  2250.         $qb = $this->getEntityManager()->createQueryBuilder();
  2251.         $qb->select(['s.' . $group, 'COUNT(s.id) as number']);
  2252.         $qb->from(Startup::class, 's');
  2253.         if ($exact) {
  2254.             $qb->where("s.{$group}>''");
  2255.         }
  2257.         if ($criteria) {
  2258.             $qb = $this->setCriteria($qb, $criteria);
  2259.         }
  2261.         $qb->groupBy('s.'. $group);
  2263.         if ($order) {
  2264.             $metadata = $this->getClassMetadata();
  2265.             foreach ($order as $key => $value) {
  2266.                 if ($metadata->hasField($key)) {
  2267.                     $qb->addOrderBy('s.' . $key, $value);
  2268.                 }
  2269.                 // UP-024: Skip non-existent fields (removed: pitchDate, etc.)
  2270.             }
  2271.         } else {
  2272.             $qb->addOrderBy('s.'. $group, 'ASC');
  2273.         }
  2275.         return $qb->getQuery()->getResult();
  2277.     }
  2279.     // --- 1:n Team → Startup (UP-024) ---
  2281.     /**
  2282.      * Find all startups for a team.
  2283.      *
  2284.      * Since UP-024, a team can have multiple startups (1:n relationship).
  2285.      *
  2286.      * @return Startup[]
  2287.      */
  2288.     public function findAllByTeam(Team $team): array
  2289.     {
  2290.         return $this->createQueryBuilder('s')
  2291.             ->where('s.teamId = :teamId')
  2292.             ->setParameter('teamId', $team->getId())
  2293.             ->orderBy('s.createdAt', 'DESC')
  2294.             ->getQuery()
  2295.             ->getResult();
  2296.     }
  2298.     /**
  2299.      * Find all startups for a team by team ID.
  2300.      *
  2301.      * @return Startup[]
  2302.      */
  2303.     public function findAllByTeamId(int $teamId): array
  2304.     {
  2305.         return $this->createQueryBuilder('s')
  2306.             ->where('s.teamId = :teamId')
  2307.             ->setParameter('teamId', $teamId)
  2308.             ->orderBy('s.createdAt', 'DESC')
  2309.             ->getQuery()
  2310.             ->getResult();
  2311.     }
  2313.     /**
  2314.      * Count startups for a team.
  2315.      */
  2316.     public function countByTeam(Team $team): int
  2317.     {
  2318.         return (int) $this->createQueryBuilder('s')
  2319.             ->select('COUNT(s.id)')
  2320.             ->where('s.teamId = :teamId')
  2321.             ->setParameter('teamId', $team->getId())
  2322.             ->getQuery()
  2323.             ->getSingleScalarResult();
  2324.     }
  2326. }