Update app.py

app.py

@@ -667,12 +667,15 @@ def _create_product_all_variants_with_grid(
     return created
 
 
-def _update_product_enable_chunk_with_grid(
+def _update_product_stitch_cumulative_with_grid(
     logs: List[str],
     shop_id: str,
     product_id: str,
-    enabled_variants: List[Dict[str, Any]],
+    all_variants: List[Dict[str, Any]],
+    enabled_ids: set,
     upload: Dict[str, Any],
+    title: Optional[str],
+    description: Optional[str],
 ) -> Dict[str, Any]:
     img_id = upload.get("id")
     img_w = float(upload.get("width") or 0)
@@ -682,7 +685,7 @@ def _update_product_enable_chunk_with_grid(
     print_areas_payload = []
 
     enabled_count = 0
-    for v in enabled_variants:
+    for v in all_variants:
         if not isinstance(v, dict):
             continue
         vid = v.get("id")
@@ -692,13 +695,28 @@ def _update_product_enable_chunk_with_grid(
             vid_i = int(vid)
         except Exception:
             continue
-        enabled_count += 1
+        is_on = vid_i in enabled_ids
+        if is_on:
+            enabled_count += 1
         variants_payload.append({
             "id": vid_i,
             "price": 1,
-            "is_enabled": True,
+            "is_enabled": bool(is_on),
         })
 
+    for v in all_variants:
+        if not isinstance(v, dict):
+            continue
+        vid = v.get("id")
+        if vid is None:
+            continue
+        try:
+            vid_i = int(vid)
+        except Exception:
+            continue
+        if vid_i not in enabled_ids:
+            continue
+
         placeholders = v.get("placeholders") or []
         if not isinstance(placeholders, list) or not placeholders:
             continue
@@ -736,20 +754,23 @@ def _update_product_enable_chunk_with_grid(
             })
 
     if not variants_payload:
-        raise RuntimeError("No variants in chunk update payload.")
-
-    if not print_areas_payload:
-        _log(logs, f"PHASE_B_UPDATE_WARN product_id={product_id} reason=no_print_areas_for_chunk enabled={enabled_count}")
+        raise RuntimeError("No variants payload could be built for stitch update.")
+    if enabled_count > 0 and not print_areas_payload:
+        raise RuntimeError("Enabled variants exist but no print_areas payload could be generated (stitch update).")
 
-    payload = {
+    payload: Dict[str, Any] = {
         "variants": variants_payload,
+        "print_areas": print_areas_payload,
     }
-    if print_areas_payload:
-        payload["print_areas"] = print_areas_payload
+    if isinstance(title, str) and title:
+        payload["title"] = title
+    if isinstance(description, str) and description:
+        payload["description"] = description
 
     _log(
         logs,
-        f"PHASE_B_UPDATE product_id={product_id} enable_variants={len(variants_payload)} "
+        f"PHASE_B_STITCH_UPDATE product_id={product_id} "
+        f"variants_payload_total={len(variants_payload)} enabled={enabled_count} "
         f"print_areas_payload={len(print_areas_payload)}",
     )
 
@@ -762,7 +783,7 @@ def _update_product_enable_chunk_with_grid(
     if not isinstance(upd, dict):
         raise RuntimeError(f"Unexpected update response: {str(upd)[:500]}")
 
-    _log(logs, f"PHASE_B_UPDATE_DONE product_id={product_id}")
+    _log(logs, f"PHASE_B_STITCH_UPDATE_DONE product_id={product_id}")
     return upd
 
 
@@ -1024,15 +1045,27 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
 
             else:
                 total_chunks = (total_variants + CHUNK_TARGET_VARIANTS - 1) // CHUNK_TARGET_VARIANTS
+
+                enabled_ids: set = set()
                 chunk_index = 0
-                offset = 0
 
                 first_chunk = variants_all[0:CHUNK_TARGET_VARIANTS]
+                for v in first_chunk:
+                    if not isinstance(v, dict):
+                        continue
+                    vid = v.get("id")
+                    if vid is None:
+                        continue
+                    try:
+                        enabled_ids.add(int(vid))
+                    except Exception:
+                        continue
+
                 p_info_first = dict(product_info_full)
                 p_info_first["variants"] = first_chunk
                 p_info_first["options"] = _rebuild_options_for_variants(first_chunk)
                 p_info_first["_allVariants"] = variants_all
-                p_info_first["_enabledVariantIds"] = [int(v.get("id")) for v in first_chunk if v.get("id") is not None]
+                p_info_first["_enabledVariantIds"] = sorted(list(enabled_ids))
 
                 _log(
                     logs,
@@ -1077,21 +1110,37 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
 
                 while offset < total_variants:
                     chunk = variants_all[offset: offset + CHUNK_TARGET_VARIANTS]
+                    for v in chunk:
+                        if not isinstance(v, dict):
+                            continue
+                        vid = v.get("id")
+                        if vid is None:
+                            continue
+                        try:
+                            enabled_ids.add(int(vid))
+                        except Exception:
+                            continue
 
                     _log(
                         logs,
-                        f"PROVIDER_CHUNK_UPDATE provider_id={provider_id} name={provider_name} "
+                        f"PROVIDER_CHUNK_STITCH provider_id={provider_id} name={provider_name} "
                         f"chunk_index={chunk_index} total_chunks={total_chunks} "
                         f"offset={offset} size={len(chunk)} total_variants={total_variants} product_id={created_id}",
                     )
                     yield flush()
 
-                    upd_enable = _update_product_enable_chunk_with_grid(
+                    current_prod = _get_product(logs, shop_id, created_id)
+                    yield flush()
+
+                    upd_stitch = _update_product_stitch_cumulative_with_grid(
                         logs,
                         shop_id=shop_id,
                         product_id=created_id,
-                        enabled_variants=chunk,
+                        all_variants=variants_all,
+                        enabled_ids=enabled_ids,
                         upload=upload,
+                        title=current_prod.get("title"),
+                        description=current_prod.get("description"),
                     )
                     yield flush()
 
@@ -1117,7 +1166,7 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                             "shopVariantCountAfterCreate": len(prod_u.get("variants") or []),
                             "shopVariantCountFinal": len(prod_u.get("variants") or []),
                             "productId": created_id,
-                            "priceUpdateResponse": upd_enable,
+                            "priceUpdateResponse": upd_stitch,
                         }
                     )