feat: create a new term

Author: williarin

README.md

@@ -357,6 +357,16 @@ $result = $repository->createFindByQueryBuilder([], ['sku' => 'ASC'])
 $products = $repository->denormalize($result, Product::class . '[]');
 ```
 
+### Create a new term
+
+Terms are not duplicated if already existing.
+
+```php
+// Create a new product category
+$repository = $manager->getRepository(Term::class);
+$term = $repository->createTermForTaxonomy('Jewelry', 'product_cat');
+```
+
 ### Add terms to an entity
 
 ```php
@@ -429,6 +439,7 @@ $newProduct =  $duplicationService->duplicate($product);
 * `Option` and `OptionRepository`
 * `PostMeta` and `PostMetaRepository`
 * `Term` and `TermRepository`
+* `TermTaxonomy` and `TermTaxonomyRepository`
 * `User` and `UserRepository`
 * `Product` and `ProductRepository` (WooCommerce)
 * `ShopOrder` and `ShopOrderRepository` (WooCommerce)

src/Bridge/Entity/DynamicPropertiesTrait.php

@@ -5,6 +5,8 @@
 namespace Williarin\WordpressInterop\Bridge\Entity;
 
 use ReflectionNamedType;
+use Williarin\WordpressInterop\Exception\InvalidArgumentException;
+use Williarin\WordpressInterop\Exception\MethodNotFoundException;
 
 trait DynamicPropertiesTrait
 {
@@ -18,7 +20,7 @@ public function __set(string $property, mixed $value): void
             $reflectionType = (new \ReflectionProperty(static::class, $property))->getType();
 
             $expectedType = $reflectionType instanceof ReflectionNamedType
-                ? $reflectionType?->getName()
+                ? $reflectionType->getName()
                 : (string) $reflectionType;
 
             settype($value, $expectedType);
@@ -32,4 +34,30 @@ public function __get(string $property): mixed
     {
         return $this->{$property};
     }
+
+    public function __isset($name): bool
+    {
+        return property_exists($this, $name);
+    }
+
+    public function __call(string $name, array $arguments): mixed
+    {
+        $propertyName = lcfirst(substr($name, 3));
+
+        if (preg_match('/^get[A-Z]/', $name)) {
+            return $this->__get($propertyName);
+        }
+
+        if (preg_match('/^set[A-Z]/', $name)) {
+            if (count($arguments) !== 1) {
+                throw new InvalidArgumentException('Setter needs a value as argument.');
+            }
+
+            $this->__set($propertyName, $arguments[0]);
+
+            return $this;
+        }
+
+        throw new MethodNotFoundException(static::class, $name);
+    }
 }

src/Bridge/Entity/Term.php

@@ -35,4 +35,16 @@ class Term
 
     #[External]
     public ?int $count = null;
+
+    public function setName(?string $name): self
+    {
+        $this->name = $name;
+        return $this;
+    }
+
+    public function setSlug(?string $slug): self
+    {
+        $this->slug = $slug;
+        return $this;
+    }
 }

src/Bridge/Entity/TermTaxonomy.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Williarin\WordpressInterop\Bridge\Entity;
+
+use AllowDynamicProperties;
+use Symfony\Component\Serializer\Annotation\Groups;
+use Williarin\WordpressInterop\Attributes\Id;
+use Williarin\WordpressInterop\Attributes\RepositoryClass;
+use Williarin\WordpressInterop\Bridge\Repository\TermTaxonomyRepository;
+
+#[AllowDynamicProperties]
+#[RepositoryClass(TermTaxonomyRepository::class)]
+class TermTaxonomy
+{
+    #[Id]
+    #[Groups('base')]
+    public ?int $termTaxonomyId = null;
+
+    #[Groups('base')]
+    public ?int $termId = null;
+
+    #[Groups('base')]
+    public ?string $taxonomy = null;
+
+    #[Groups('base')]
+    public ?string $description = null;
+
+    #[Groups('base')]
+    public int $parent = 0;
+
+    #[Groups('base')]
+    public int $count = 0;
+
+    public function setTermId(?int $termId): self
+    {
+        $this->termId = $termId;
+        return $this;
+    }
+
+    public function setTaxonomy(?string $taxonomy): self
+    {
+        $this->taxonomy = $taxonomy;
+        return $this;
+    }
+
+    public function setDescription(?string $description): self
+    {
+        $this->description = $description;
+        return $this;
+    }
+
+    public function setParent(int $parent): self
+    {
+        $this->parent = $parent;
+        return $this;
+    }
+
+    public function setCount(int $count): self
+    {
+        $this->count = $count;
+        return $this;
+    }
+}

src/Bridge/Repository/AbstractEntityRepository.php

@@ -189,7 +189,9 @@ public function persist(mixed $entity): void
 
         unset($baseFields[static::TABLE_IDENTIFIER]);
 
-        if ($entity->{static::TABLE_IDENTIFIER} === null) {
+        $identifierProperty = field_to_property(static::TABLE_IDENTIFIER);
+
+        if ($entity->{$identifierProperty} === null) {
             $this->entityManager->getConnection()
                 ->createQueryBuilder()
                 ->insert($this->entityManager->getTablesPrefix() . static::TABLE_NAME)
@@ -198,7 +200,8 @@ public function persist(mixed $entity): void
                 ->executeStatement()
             ;
 
-            $entity->{static::TABLE_IDENTIFIER} = (int) $this->entityManager->getConnection()->lastInsertId();
+            $entity->{$identifierProperty} = (int) $this->entityManager->getConnection()
+                ->lastInsertId();
         } else {
             $queryBuilder = $this->entityManager->getConnection()
                 ->createQueryBuilder()

src/Bridge/Repository/TermRepository.php

@@ -6,9 +6,12 @@
 
 use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
 use Doctrine\DBAL\Query\QueryBuilder;
+use Symfony\Component\String\Slugger\AsciiSlugger;
 use Williarin\WordpressInterop\Bridge\Entity\BaseEntity;
 use Williarin\WordpressInterop\Bridge\Entity\Term;
+use Williarin\WordpressInterop\Bridge\Entity\TermTaxonomy;
 use Williarin\WordpressInterop\Criteria\SelectColumns;
+use Williarin\WordpressInterop\Exception\EntityNotFoundException;
 
 class TermRepository extends AbstractEntityRepository
 {
@@ -56,6 +59,42 @@ public function createFindByQueryBuilder(array $criteria, ?array $orderBy): Quer
         return $queryBuilder;
     }
 
+    public function createTermForTaxonomy(string $termName, string $taxonomy): Term
+    {
+        try {
+            $term = $this->findOneBy([
+                'name' => $termName,
+                'taxonomy' => $taxonomy
+            ]);
+        } catch (EntityNotFoundException) {
+            $term = (new Term())
+                ->setName($termName)
+                ->setSlug((new AsciiSlugger())->slug($termName)->lower()->toString())
+            ;
+
+            $this->persist($term);
+
+            $termTaxonomy = (new TermTaxonomy())
+                ->setTermId($term->termId)
+                ->setTaxonomy($taxonomy)
+            ;
+
+            $this->entityManager->getRepository(TermTaxonomy::class)
+                ->persist($termTaxonomy)
+            ;
+
+            $term = $this->findOneBy([
+                'name' => $termName,
+                'taxonomy' => $taxonomy
+            ]);
+        }
+
+        return $term;
+    }
+
+    /**
+     * @param Term[] $terms
+     */
     public function addTermsToEntity(BaseEntity $entity, array $terms): void
     {
         foreach ($terms as $term) {
@@ -82,6 +121,9 @@ public function addTermsToEntity(BaseEntity $entity, array $terms): void
         $this->recountTerms();
     }
 
+    /**
+     * @param Term[] $terms
+     */
     public function removeTermsFromEntity(BaseEntity $entity, array $terms): void
     {
         foreach ($terms as $term) {

src/Bridge/Repository/TermTaxonomyRepository.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Williarin\WordpressInterop\Bridge\Repository;
+
+use Williarin\WordpressInterop\Bridge\Entity\TermTaxonomy;
+
+class TermTaxonomyRepository extends AbstractEntityRepository
+{
+    protected const TABLE_NAME = 'term_taxonomy';
+    protected const TABLE_IDENTIFIER = 'term_taxonomy_id';
+    protected const FALLBACK_ENTITY = TermTaxonomy::class;
+
+    public function __construct()
+    {
+        parent::__construct(TermTaxonomy::class);
+    }
+}

test/Test/Bridge/Repository/PostRepositoryTest.php

@@ -9,6 +9,7 @@
 use Williarin\WordpressInterop\Bridge\Repository\EntityRepositoryInterface;
 use Williarin\WordpressInterop\Criteria\Operand;
 use Williarin\WordpressInterop\Exception\EntityNotFoundException;
+use Williarin\WordpressInterop\Exception\InvalidArgumentException;
 use Williarin\WordpressInterop\Exception\InvalidEntityException;
 use Williarin\WordpressInterop\Exception\InvalidFieldNameException;
 use Williarin\WordpressInterop\Exception\InvalidOrderByOrientationException;
@@ -267,4 +268,36 @@ public function testPersistExistingPost(): void
         self::assertSame('Another post with a new title', $post->postTitle);
         self::assertSame('publish', $post->postStatus);
     }
+
+    public function testDynamicSetter(): void
+    {
+        $post = new Post();
+
+        $post = $post->setDynamicProperty('Hello');
+        self::assertSame('Hello', $post->dynamicProperty);
+    }
+
+    public function testDynamicSetterNoArgument(): void
+    {
+        $post = new Post();
+
+        $this->expectException(InvalidArgumentException::class);
+        $post->setDynamicProperty();
+    }
+
+    public function testWrongMethodCall(): void
+    {
+        $post = new Post();
+
+        $this->expectException(MethodNotFoundException::class);
+        $post->nonExistentMethod();
+    }
+
+    public function testDynamicGetter(): void
+    {
+        $post = new Post();
+        $post->postContent = 'Hello';
+
+        self::assertSame('Hello', $post->getPostContent());
+    }
 }

test/Test/Bridge/Repository/TermRepositoryTest.php

@@ -14,6 +14,8 @@
 use Williarin\WordpressInterop\Criteria\SelectColumns;
 use Williarin\WordpressInterop\Test\TestCase;
 
+use function Williarin\WordpressInterop\Util\String\field_to_property;
+
 class TermRepositoryTest extends TestCase
 {
     /** @var TermRepository */
@@ -99,6 +101,27 @@ public function testFindByPostRelationshipCondition(): void
         ], array_combine(array_column($terms, 'taxonomy'), array_column($terms, 'name')));
     }
 
+    public function testCreateNewTermForTaxonomy(): void
+    {
+        $term = $this->repository->createTermForTaxonomy('Jewelry', 'product_cat');
+
+        $this->validateTerm($term, [
+            'name' => 'Jewelry',
+            'slug' => 'jewelry',
+            'taxonomy' => 'product_cat',
+            'count' => 0,
+        ]);
+    }
+
+    public function testCreateTermForTaxonomyNoDuplicate(): void
+    {
+        $term1 = $this->repository->createTermForTaxonomy('Jewelry', 'product_cat');
+        $term2 = $this->repository->createTermForTaxonomy('Jewelry', 'product_cat');
+
+        self::assertEquals($term1, $term2);
+        self::assertNotSame($term1, $term2);
+    }
+
     public function testAddTermsToEntity(): void
     {
         $hoodieTerms = $this->repository->findBy([
@@ -295,4 +318,14 @@ static function (Term $term) {
 
         self::assertEquals(['simple', 'Hoodies', 'MegaBrand'], array_column($terms, 'name'));
     }
+
+    private function validateTerm(Term $term, array $values): void
+    {
+        foreach ($values as $key => $value) {
+            self::assertEquals($value, $term->{field_to_property($key)});
+        }
+
+        self::assertIsInt($term->termId);
+        self::assertIsInt($term->termTaxonomyId);
+    }
 }