src/Manager/AttributeManager.php line 249

Open in your IDE?
  1. <?php
  3. namespace App\Manager;
  5. use Doctrine\ORM\EntityManagerInterface;
  6. use App\Entity\Product;
  7. use App\Entity\ProductModel;
  8. use App\Entity\Category;
  9. use App\Entity\Attribute;
  10. use App\Entity\Language;
  11. use App\Entity\ProductAttribute;
  13. class AttributeManager {
  15. private $em;
  16. private $projectDir;
  17. private $attributeCache = [];
  19. /**
  20. * Ne garde que les id (pas les entités Language elles-mêmes) : contrairement
  21. * à $attributeCache, ce cache reste valide même après un em->clear().
  22. */
  23. private array $languageIdCache = [];
  25. public function __construct(EntityManagerInterface $em, \Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface $parameter)
  26. {
  27. $this->em = $em;
  28. $this->projectDir = $parameter->get('kernel.project_dir').'/';
  29. }
  31. public function createAttribute(string $code): Attribute{
  32. $attribute = new Attribute();
  33. $attribute->setCode($code);
  34. $attribute->setStatus(0);
  35. $this->em->persist($attribute);
  36. return $attribute;
  37. }
  39. public function getAttribute(string $code): ?Attribute{
  40. if (isset($this->attributeCache[$code])) {
  41. return $this->attributeCache[$code];
  42. }
  43. $attribute = $this->em->getRepository(Attribute::class)->findOneByCode($code);
  44. if (!$attribute) {
  45. $attribute = $this->createAttribute($code);
  46. }
  47. $this->attributeCache[$code] = $attribute;
  48. return $attribute;
  49. }
  51. /**
  52. * The cached Attribute entities become detached after an em->clear(); call this right after
  53. * to avoid reusing stale references on the next lookups.
  54. */
  55. public function resetCache(): void {
  56. $this->attributeCache = [];
  57. }
  59. public function createAttributeDescription(Attribute $attribute, $isoCode = 'fr'): \App\Entity\AttributeDescription{
  60. $language = $this->getLanguageByCode($isoCode);
  61. $ad = new \App\Entity\AttributeDescription();
  62. $ad->setAttribute($attribute);
  63. $ad->setLanguage($language);
  64. $ad->setTitle('');
  65. return $ad;
  66. }
  68. public function createProductAttributeDescription(ProductAttribute $pa, $isoCode = 'fr'): \App\Entity\ProductAttributeDescription{
  69. $language = $this->getLanguageByCode($isoCode);
  70. $ad = new \App\Entity\ProductAttributeDescription();
  71. $ad->setProductAttribute($pa);
  72. $ad->setLanguage($language);
  73. $ad->setValue('');
  74. return $ad;
  75. }
  77. /**
  78. * Résout une langue par son code sans refaire une requête à chaque appel
  79. * (le nombre de codes distincts utilisés dans un import est très faible).
  80. */
  81. private function getLanguageByCode(string $isoCode): ?Language
  82. {
  83. if (!array_key_exists($isoCode, $this->languageIdCache)) {
  84. $language = $this->em->getRepository(Language::class)->findOneByCode($isoCode);
  85. $this->languageIdCache[$isoCode] = $language?->getId();
  86. }
  87. $id = $this->languageIdCache[$isoCode];
  89. return $id !== null ? $this->em->getReference(Language::class, $id) : null;
  90. }
  92. public function addToProduct(Attribute $attribute, Product $product, string $value, $locale = null, bool $flush = true) {
  93. $pa = $product->getAttribute($attribute->getCode());
  94. if(empty($pa)) {
  95. $pa = new \App\Entity\ProductAttribute();
  96. $pa->setAttribute($attribute);
  97. $pa->setProduct($product);
  98. }
  99. if(is_null($locale)) {
  100. $pa->setValue($value);
  101. }else{
  102. // pas de getDescription() ici : son repli sur la première description écraserait une autre langue
  103. $description = $pa->getDescriptionByLanguage($locale == 'fr' ? 4 : 1);
  104. if(empty($description)) {
  105. $description = $this->createProductAttributeDescription($pa, $locale);
  106. }
  107. $description->setValue($value);
  108. $this->em->persist($description);
  109. }
  110. $this->em->persist($pa);
  111. if ($flush) {
  112. $this->em->flush();
  113. }
  114. }
  116. public function removeFromProduct(Attribute $attribute, Product $product) {
  117. $pas = $this->em->getRepository('App:ProductAttribute')->findBy([
  118. 'product' => $product,
  119. 'attribute' => $attribute
  120. ]);
  121. foreach($pas as $pa){
  122. $this->em->remove($pa);
  123. }
  124. $this->em->flush();
  125. }
  127. public function addToProductModel(Attribute $attribute, ProductModel $product, string $value) {
  128. $pa = $this->em->getRepository('App:ProductModelAttribute')->findOneBy([
  129. 'attribute' => $attribute,
  130. 'productModel' => $product
  131. ]);
  132. if(empty($pa)) {
  133. $pa = new \App\Entity\ProductModelAttribute();
  134. $pa->setAttribute($attribute);
  135. $pa->setProductModel($product);
  136. }
  137. $pa->setValue($value);
  138. $this->em->persist($pa);
  139. $this->em->flush();
  140. }
  142. public function removeFromProductModel(Attribute $attribute, ProductModel $model) {
  143. $pas = $this->em->getRepository('App:ProductModelAttribute')->findBy([
  144. 'productModel' => $model,
  145. 'attribute' => $attribute
  146. ]);
  147. foreach($pas as $pa){
  148. $this->em->remove($pa);
  149. }
  150. $this->em->flush();
  151. }
  153. public function getAttributesByProductModel(ProductModel $productModel): array {
  154. $attributes = [];
  155. $variant = $productModel->getVariant();
  156. if (!$variant) {
  157. return $attributes;
  158. }
  159. foreach ([$variant->getAxis1(), $variant->getAxis2()] as $axis) {
  160. if (!$axis) {
  161. continue;
  162. }
  163. $codes = array_values(array_filter(array_map('trim', explode(',', $axis))));
  164. if (count($codes) === 1) {
  165. $attribute = $this->getAttribute($codes[0]);
  166. if ($attribute && $attribute->isVariant()) {
  167. $attribute->setValues($this->getAttributeValuesByProductModel($attribute, $productModel));
  168. $attributes[] = $attribute;
  169. }
  170. } else {
  171. $composite = $this->buildCompositeAxis($codes, $productModel);
  172. if ($composite) {
  173. $attributes[] = $composite;
  174. }
  175. }
  176. }
  177. // Les axes affichés en couleur passent en premier (usort est stable : l'ordre des axes est conservé sinon)
  178. $isColor = fn($attribute) => ($attribute instanceof Attribute ? $attribute->getDisplay() : $attribute->display) === Attribute::DISPLAY_TYPE_COLOR;
  179. usort($attributes, fn($a, $b) => $isColor($b) <=> $isColor($a));
  180. return $attributes;
  181. }
  183. /**
  184. * Builds a synthetic axis object for multi-attribute axes (e.g. axis = "taille,couleur").
  185. * Returns a stdClass with code/title/display/values so Twig can render it like a regular Attribute.
  186. * Each value has ->value (combined label "XS / Rouge") and ->product (the matching Product).
  187. */
  188. private function buildCompositeAxis(array $codes, ProductModel $productModel): ?\stdClass {
  189. $axisAttributes = [];
  190. foreach ($codes as $code) {
  191. $attr = $this->em->getRepository(Attribute::class)->findOneByCode($code);
  192. if ($attr) {
  193. $axisAttributes[] = $attr;
  194. }
  195. }
  196. if (empty($axisAttributes)) {
  197. return null;
  198. }
  200. $values = [];
  201. $seen = [];
  202. $sortKeys = [];
  203. foreach ($productModel->getAllProducts() as $product) {
  204. $parts = [];
  205. $productAttributes = [];
  206. foreach ($axisAttributes as $attr) {
  207. $pa = $product->getAttribute($attr->getCode());
  208. $parts[] = $pa ? ($pa->getDisplayedValue() ?? '?') : '?';
  209. $productAttributes[] = $pa;
  210. }
  211. $label = implode(' / ', $parts);
  212. if (in_array($label, $seen)) {
  213. continue;
  214. }
  215. $seen[] = $label;
  216. $value = new \stdClass();
  217. $value->value = $label;
  218. $value->product = $product;
  219. $values[] = $value;
  220. $sortKeys[] = $productAttributes;
  221. }
  223. // Tri sur chaque attribut de l'axe, dans l'ordre de l'axe
  224. $indexes = array_keys($values);
  225. usort($indexes, function ($a, $b) use ($sortKeys) {
  226. foreach ($sortKeys[$a] as $i => $pa) {
  227. $cmp = $this->compareProductAttributes($pa, $sortKeys[$b][$i]);
  228. if ($cmp !== 0) {
  229. return $cmp;
  230. }
  231. }
  232. return 0;
  233. });
  234. $values = array_map(fn($i) => $values[$i], $indexes);
  236. $composite = new \stdClass();
  237. $composite->code = implode(',', $codes);
  238. $composite->title = implode(' / ', array_map(fn(Attribute $a) => $a->getTitle(), $axisAttributes));
  239. $composite->display = Attribute::DISPLAY_TYPE_COMBOBOX;
  240. $composite->values = $values;
  241. return $composite;
  242. }
  244. public function getAttributeValuesByProductModel(Attribute $attribute, ProductModel $productModel) {
  245. $values = [];
  246. $tmp = [];
  247. $products = $productModel->getAllProducts();
  248. foreach($products as $product) {
  249. $attr = $product->getAttribute($attribute->getCode());
  250. if($attr && !in_array($attr->getValue(), $tmp)) {
  251. $values[] = $attr;
  252. $tmp[] = $attr->getValue();
  253. }
  254. }
  255. usort($values, fn($a, $b) => $this->compareProductAttributes($a, $b));
  256. return $values;
  257. }
  259. /**
  260. * Compare deux valeurs d'attribut produit : numériquement si les deux valeurs brutes sont
  261. * des nombres (500 ml avant 1 l), sinon par ordre naturel sur la valeur affichée (traduite).
  262. * Les valeurs absentes sont placées en fin.
  263. * Pour product_size, les tailles textiles suivent l'ordre XXXS … XS, S, M, L, X, XL … XXXL.
  264. */
  265. private function compareProductAttributes(?ProductAttribute $a, ?ProductAttribute $b): int {
  266. if (!$a || !$b) {
  267. return ($a ? 0 : 1) - ($b ? 0 : 1);
  268. }
  269. if ($a->getAttribute() && $a->getAttribute()->getCode() === 'product_size') {
  270. $rankA = $this->getSizeRank($a);
  271. $rankB = $this->getSizeRank($b);
  272. if (!is_null($rankA) || !is_null($rankB)) {
  273. // tailles inconnues après les tailles reconnues
  274. if (is_null($rankA) || is_null($rankB)) {
  275. return is_null($rankA) ? 1 : -1;
  276. }
  277. if ($rankA != $rankB) {
  278. return $rankA <=> $rankB;
  279. }
  280. }
  281. }
  282. $rawA = str_replace(',', '.', trim((string) $a->getValue()));
  283. $rawB = str_replace(',', '.', trim((string) $b->getValue()));
  284. if (is_numeric($rawA) && is_numeric($rawB)) {
  285. return (float) $rawA <=> (float) $rawB;
  286. }
  287. return strnatcasecmp((string) $a->getDisplayedValue(), (string) $b->getDisplayedValue());
  288. }
  290. /**
  291. * Rang d'une taille textile (M = 0, S/XS/… négatifs, L/X/XL/… positifs), à partir de la valeur
  292. * brute puis de la valeur affichée. Accepte la forme numérique (2XL = XXL, 3XS = XXXS).
  293. * Null si la valeur n'est pas une taille reconnue.
  294. */
  295. private function getSizeRank(ProductAttribute $pa): ?float {
  296. foreach ([$pa->getValue(), $pa->getDisplayedValue()] as $value) {
  297. $value = strtoupper(preg_replace('/[\s._-]+/', '', (string) $value));
  298. if ($value === 'M') {
  299. return 0;
  300. }
  301. if ($value === 'X') {
  302. return 1.5;
  303. }
  304. if (preg_match('/^(\d+)?(X*)(S|L)$/', $value, $m)) {
  305. $nbX = $m[1] !== '' ? (int) $m[1] : strlen($m[2]);
  306. if ($m[1] !== '' && $m[2] !== 'X') {
  307. // forme numérique : seul "2XL" / "3XS" est valide
  308. continue;
  309. }
  310. return $m[3] === 'S' ? -($nbX + 1) : $nbX + 1;
  311. }
  312. }
  313. return null;
  314. }
  316. }