802 lines
30 KiB
Python
802 lines
30 KiB
Python
"""Scryfall-specific MTG card import helpers for the MTG connector."""
|
|
|
|
import re
|
|
|
|
from odoo import _, Command, api, fields, models
|
|
|
|
KEYWORD_CODE_PATTERN = re.compile(r"[^a-z0-9]+")
|
|
|
|
|
|
class MvdTcgCard(models.Model):
|
|
"""Extend MTG card references with Scryfall connector metadata."""
|
|
|
|
_inherit = "mvd.tcg.card"
|
|
|
|
mtg_scryfall_id = fields.Char(string="Scryfall ID", index=True)
|
|
mtg_scryfall_uri = fields.Char(string="Scryfall URL", copy=False, readonly=True)
|
|
mtg_scryfall_last_import_run_id = fields.Many2one(
|
|
"mvd.tcg.mtg.scryfall.import.run",
|
|
string="Last Import Run",
|
|
copy=False,
|
|
index=True,
|
|
ondelete="set null",
|
|
readonly=True,
|
|
)
|
|
mtg_scryfall_last_synced_at = fields.Datetime(
|
|
string="Last Synced At",
|
|
copy=False,
|
|
readonly=True,
|
|
)
|
|
mtg_scryfall_image_ids = fields.One2many(
|
|
"mvd.tcg.mtg.card.image",
|
|
"card_id",
|
|
string="Localized Images",
|
|
copy=False,
|
|
readonly=True,
|
|
)
|
|
mtg_display_image_1920 = fields.Image(
|
|
string="Localized Image",
|
|
compute="_compute_mtg_display_images",
|
|
max_width=1920,
|
|
max_height=1920,
|
|
)
|
|
mtg_display_image_512 = fields.Image(
|
|
string="Localized Preview Image",
|
|
compute="_compute_mtg_display_images",
|
|
max_width=512,
|
|
max_height=512,
|
|
)
|
|
|
|
def _mvd_tcg_get_deck_image_binary(self):
|
|
"""Prefer localized display images for deck previews.
|
|
|
|
Returns:
|
|
str | bool: Base64 image data for deck-related previews.
|
|
"""
|
|
self.ensure_one()
|
|
return (
|
|
self.mtg_display_image_512
|
|
or self.mtg_display_image_1920
|
|
or super()._mvd_tcg_get_deck_image_binary()
|
|
)
|
|
|
|
def _mtg_scryfall_get_refresh_query(self):
|
|
"""Return the preferred lookup query for a Scryfall refresh.
|
|
|
|
Returns:
|
|
str | bool: URL or identifier reusable by the shared lookup parser.
|
|
"""
|
|
self.ensure_one()
|
|
if self.mtg_scryfall_uri:
|
|
return self.mtg_scryfall_uri
|
|
if self.mtg_scryfall_id:
|
|
return self.mtg_scryfall_id
|
|
if self.mtg_set_code and self.mtg_collector_number:
|
|
return (
|
|
f"https://api.scryfall.com/cards/"
|
|
f"{self.mtg_set_code}/{self.mtg_collector_number}"
|
|
)
|
|
return False
|
|
|
|
@api.model
|
|
def _mtg_scryfall_build_external_ref(self, payload):
|
|
"""Build the stable MTG print reference used by the connector.
|
|
|
|
Args:
|
|
payload: Raw Scryfall card payload.
|
|
|
|
Returns:
|
|
str: Stable reference in ``set_code:collector_number`` form.
|
|
"""
|
|
set_code = (payload.get("set") or "").strip().lower()
|
|
collector_number = (payload.get("collector_number") or "").strip().lower()
|
|
return f"{set_code}:{collector_number}"
|
|
|
|
@api.model
|
|
def _mtg_scryfall_select_primary_payload(self, payloads):
|
|
"""Return the payload that should drive primary MTG field values.
|
|
|
|
Args:
|
|
payloads: Raw localized Scryfall payloads for one print group.
|
|
|
|
Returns:
|
|
dict: Primary payload, preferring English when available.
|
|
"""
|
|
valid_payloads = [
|
|
payload
|
|
for payload in (payloads or [])
|
|
if payload.get("object") == "card" and payload.get("id")
|
|
]
|
|
if not valid_payloads:
|
|
return {}
|
|
|
|
english_payload = next(
|
|
(
|
|
payload
|
|
for payload in valid_payloads
|
|
if (payload.get("lang") or "").strip().lower() == "en"
|
|
),
|
|
False,
|
|
)
|
|
return english_payload or valid_payloads[0]
|
|
|
|
@api.model
|
|
def _mtg_scryfall_extract_image_url(self, payload):
|
|
"""Return the best image URL available for a Scryfall payload.
|
|
|
|
Args:
|
|
payload: Raw Scryfall card payload.
|
|
|
|
Returns:
|
|
str | bool: Image URL or ``False`` when none is available.
|
|
"""
|
|
image_uris = payload.get("image_uris") or {}
|
|
if image_uris.get("normal"):
|
|
return image_uris["normal"]
|
|
|
|
for face_payload in payload.get("card_faces") or []:
|
|
face_image_uris = face_payload.get("image_uris") or {}
|
|
if face_image_uris.get("normal"):
|
|
return face_image_uris["normal"]
|
|
return False
|
|
|
|
@api.model
|
|
def _mtg_scryfall_load_group_image_base64(self, payloads):
|
|
"""Load the best available card image for one localized print group.
|
|
|
|
Args:
|
|
payloads: Raw localized Scryfall payloads for one print group.
|
|
|
|
Returns:
|
|
str | bool: Base64-encoded image data or ``False`` when unavailable.
|
|
"""
|
|
scryfall_api = self.env["mvd.tcg.mtg.scryfall.api"]
|
|
for payload in payloads or ():
|
|
image_base64 = scryfall_api.load_image_base64(
|
|
self._mtg_scryfall_extract_image_url(payload)
|
|
)
|
|
if image_base64:
|
|
return image_base64
|
|
return False
|
|
|
|
@api.model
|
|
def _mtg_scryfall_collect_group_images(self, payloads):
|
|
"""Collect localized imported images for one Scryfall print group.
|
|
|
|
Args:
|
|
payloads: Raw localized Scryfall payloads for one print group.
|
|
|
|
Returns:
|
|
dict[str, str]: Base64 image data keyed by Scryfall language code.
|
|
"""
|
|
scryfall_api = self.env["mvd.tcg.mtg.scryfall.api"]
|
|
collected_images = {}
|
|
for payload in payloads or ():
|
|
language_code = (payload.get("lang") or "").strip().lower() or "en"
|
|
if language_code in collected_images:
|
|
continue
|
|
image_base64 = scryfall_api.load_image_base64(
|
|
self._mtg_scryfall_extract_image_url(payload)
|
|
)
|
|
if image_base64:
|
|
collected_images[language_code] = image_base64
|
|
return collected_images
|
|
|
|
@api.model
|
|
def _mtg_scryfall_extract_card_type_codes(self, payload):
|
|
"""Extract normalized MTG card type codes from a Scryfall payload.
|
|
|
|
Args:
|
|
payload: Raw Scryfall card payload.
|
|
|
|
Returns:
|
|
list[str]: Known MTG card type codes present on the card.
|
|
"""
|
|
known_codes = {
|
|
card_type.code: card_type.code
|
|
for card_type in self.env["mvd.tcg.mtg.card.type"].search([])
|
|
}
|
|
raw_type_values = [payload.get("type_line")]
|
|
raw_type_values.extend(
|
|
face_payload.get("type_line")
|
|
for face_payload in payload.get("card_faces") or []
|
|
)
|
|
extracted_codes = []
|
|
for raw_type_value in raw_type_values:
|
|
normalized_value = (raw_type_value or "").replace("—", " ")
|
|
for token in normalized_value.split():
|
|
type_code = token.strip().lower()
|
|
if type_code in known_codes and type_code not in extracted_codes:
|
|
extracted_codes.append(type_code)
|
|
return extracted_codes
|
|
|
|
@api.model
|
|
def _mtg_scryfall_extract_face_payloads(self, payload):
|
|
"""Return ordered card-face payloads from one Scryfall payload.
|
|
|
|
Args:
|
|
payload: Raw Scryfall card payload.
|
|
|
|
Returns:
|
|
list[dict]: Ordered face payloads, or an empty list for single-face cards.
|
|
"""
|
|
return [
|
|
face_payload
|
|
for face_payload in (payload.get("card_faces") or [])
|
|
if isinstance(face_payload, dict)
|
|
]
|
|
|
|
@api.model
|
|
def _mtg_scryfall_normalize_keyword_code(self, keyword_name):
|
|
"""Build a stable code for one MTG keyword.
|
|
|
|
Args:
|
|
keyword_name: Human keyword such as ``Double strike``.
|
|
|
|
Returns:
|
|
str: Normalized keyword code.
|
|
"""
|
|
normalized_keyword = KEYWORD_CODE_PATTERN.sub(
|
|
"-",
|
|
(keyword_name or "").strip().lower(),
|
|
).strip("-")
|
|
return normalized_keyword or False
|
|
|
|
@api.model
|
|
def _mtg_scryfall_resolve_taxonomy_records(
|
|
self,
|
|
model_name,
|
|
codes,
|
|
*,
|
|
display_names=None,
|
|
create_missing=False,
|
|
):
|
|
"""Resolve normalized taxonomy records from codes.
|
|
|
|
Args:
|
|
model_name: Technical taxonomy model name.
|
|
codes: Raw taxonomy codes.
|
|
display_names: Optional display names keyed by normalized code.
|
|
create_missing: Whether unknown codes should be created.
|
|
|
|
Returns:
|
|
Model: Matching taxonomy records.
|
|
"""
|
|
normalized_codes = []
|
|
for code in codes or []:
|
|
normalized_code = (code or "").strip().lower()
|
|
if normalized_code and normalized_code not in normalized_codes:
|
|
normalized_codes.append(normalized_code)
|
|
if not normalized_codes:
|
|
return self.env[model_name]
|
|
|
|
taxonomy_model = self.env[model_name]
|
|
taxonomy_records = taxonomy_model.search([("code", "in", normalized_codes)])
|
|
records_by_code = {record.code: record for record in taxonomy_records}
|
|
if create_missing:
|
|
for normalized_code in normalized_codes:
|
|
if normalized_code in records_by_code:
|
|
continue
|
|
display_name = (display_names or {}).get(normalized_code) or normalized_code
|
|
taxonomy_record = taxonomy_model.create(
|
|
{
|
|
"name": display_name,
|
|
"code": normalized_code,
|
|
}
|
|
)
|
|
records_by_code[normalized_code] = taxonomy_record
|
|
return taxonomy_model.browse(
|
|
[records_by_code[code].id for code in normalized_codes if code in records_by_code]
|
|
)
|
|
|
|
@api.model
|
|
def _mtg_scryfall_map_translation_language_codes(self, scryfall_language_code):
|
|
"""Map one Scryfall language code to active Odoo language codes.
|
|
|
|
Args:
|
|
scryfall_language_code: Raw Scryfall language code such as ``de``.
|
|
|
|
Returns:
|
|
list[str]: Active Odoo language codes for translation updates.
|
|
"""
|
|
return self.env["mvd.tcg.mtg.scryfall.api"].map_translation_language_codes(
|
|
scryfall_language_code
|
|
)
|
|
|
|
def _mtg_scryfall_update_translations_from_payload(self, payload):
|
|
"""Update translated MTG card fields from one localized payload.
|
|
|
|
Args:
|
|
payload: Raw localized Scryfall card payload.
|
|
|
|
Returns:
|
|
None: The record is updated in place.
|
|
"""
|
|
self.ensure_one()
|
|
card = self.with_context(
|
|
mvd_tcg_bypass_validated_write=True,
|
|
mvd_tcg_bypass_external_ref_write=True,
|
|
)
|
|
|
|
language_codes = card._mtg_scryfall_map_translation_language_codes(
|
|
payload.get("lang")
|
|
)
|
|
if not language_codes:
|
|
return
|
|
|
|
translated_values = {
|
|
"name": payload.get("printed_name") or payload.get("name") or False,
|
|
"mtg_type_line": payload.get("printed_type_line") or payload.get("type_line") or False,
|
|
"mtg_oracle_text": payload.get("printed_text") or payload.get("oracle_text") or False,
|
|
"mtg_flavor_text": payload.get("flavor_text") or False,
|
|
}
|
|
for field_name, field_value in translated_values.items():
|
|
if field_value:
|
|
card.update_field_translations(
|
|
field_name,
|
|
{
|
|
language_code: field_value
|
|
for language_code in language_codes
|
|
},
|
|
)
|
|
|
|
def _mtg_scryfall_update_face_translations_from_payload(self, payload):
|
|
"""Update translated face fields from one localized Scryfall payload.
|
|
|
|
Args:
|
|
payload: Raw localized Scryfall card payload.
|
|
|
|
Returns:
|
|
None: The record is updated in place.
|
|
"""
|
|
self.ensure_one()
|
|
|
|
language_codes = self._mtg_scryfall_map_translation_language_codes(
|
|
payload.get("lang")
|
|
)
|
|
if not language_codes:
|
|
return
|
|
|
|
localized_faces = self._mtg_scryfall_extract_face_payloads(payload)
|
|
if not localized_faces:
|
|
return
|
|
|
|
faces_by_sequence = {face.sequence: face for face in self.mtg_face_ids}
|
|
for index, face_payload in enumerate(localized_faces, start=1):
|
|
face = faces_by_sequence.get(index)
|
|
if not face:
|
|
continue
|
|
translated_values = {
|
|
"name": face_payload.get("printed_name") or face_payload.get("name") or False,
|
|
"type_line": face_payload.get("printed_type_line") or face_payload.get("type_line") or False,
|
|
"oracle_text": face_payload.get("printed_text") or face_payload.get("oracle_text") or False,
|
|
"flavor_text": face_payload.get("flavor_text") or False,
|
|
}
|
|
for field_name, field_value in translated_values.items():
|
|
if field_value:
|
|
face.with_context(
|
|
mvd_tcg_bypass_validated_write=True,
|
|
mvd_tcg_bypass_external_ref_write=True,
|
|
).update_field_translations(
|
|
field_name,
|
|
{
|
|
language_code: field_value
|
|
for language_code in language_codes
|
|
},
|
|
)
|
|
|
|
def _mtg_scryfall_get_preferred_image_language_codes(self):
|
|
"""Return preferred Scryfall image languages for the current UI context.
|
|
|
|
Returns:
|
|
list[str]: Ordered Scryfall language codes with fallbacks.
|
|
"""
|
|
self.ensure_one()
|
|
|
|
scryfall_api = self.env["mvd.tcg.mtg.scryfall.api"]
|
|
current_odoo_language_code = self.env.context.get("lang") or self.env.user.lang
|
|
language_codes = []
|
|
|
|
preferred_scryfall_code = scryfall_api.map_scryfall_language_code(
|
|
current_odoo_language_code
|
|
)
|
|
if preferred_scryfall_code:
|
|
language_codes.append(preferred_scryfall_code)
|
|
if "en" not in language_codes:
|
|
language_codes.append("en")
|
|
return language_codes
|
|
|
|
def _mtg_scryfall_sync_localized_images(self, localized_images):
|
|
"""Create or update localized imported images for the current card.
|
|
|
|
Args:
|
|
localized_images: Base64 image data keyed by Scryfall language code.
|
|
|
|
Returns:
|
|
None: The record is updated in place.
|
|
"""
|
|
self.ensure_one()
|
|
card = self.with_context(
|
|
mvd_tcg_bypass_validated_write=True,
|
|
mvd_tcg_bypass_external_ref_write=True,
|
|
)
|
|
|
|
image_model = self.env["mvd.tcg.mtg.card.image"]
|
|
existing_images = {
|
|
(image.language_code or "").strip().lower(): image
|
|
for image in card.mtg_scryfall_image_ids
|
|
}
|
|
for language_code, image_base64 in (localized_images or {}).items():
|
|
normalized_language_code = (language_code or "").strip().lower()
|
|
if not normalized_language_code or not image_base64:
|
|
continue
|
|
|
|
existing_image = existing_images.get(normalized_language_code)
|
|
values = {
|
|
"card_id": self.id,
|
|
"language_code": normalized_language_code,
|
|
"image_1920": image_base64,
|
|
}
|
|
if existing_image:
|
|
existing_image.write({"image_1920": image_base64})
|
|
else:
|
|
image_model.create(values)
|
|
|
|
def _mtg_scryfall_sync_faces_from_payloads(self, payloads):
|
|
"""Create or update ordered MTG card faces from localized payloads.
|
|
|
|
Args:
|
|
payloads: Raw localized Scryfall payloads for one print group.
|
|
|
|
Returns:
|
|
None: The card faces are synchronized in place.
|
|
"""
|
|
self.ensure_one()
|
|
card = self.with_context(
|
|
mvd_tcg_bypass_validated_write=True,
|
|
mvd_tcg_bypass_external_ref_write=True,
|
|
)
|
|
|
|
primary_payload = self._mtg_scryfall_select_primary_payload(payloads)
|
|
primary_face_payloads = self._mtg_scryfall_extract_face_payloads(primary_payload)
|
|
existing_faces = {face.sequence: face for face in card.mtg_face_ids}
|
|
kept_face_ids = []
|
|
|
|
for index, face_payload in enumerate(primary_face_payloads, start=1):
|
|
values = {
|
|
"card_id": self.id,
|
|
"sequence": index,
|
|
"name": face_payload.get("name") or _("Face %s") % index,
|
|
"mana_cost": face_payload.get("mana_cost") or False,
|
|
"type_line": face_payload.get("type_line") or False,
|
|
"oracle_text": face_payload.get("oracle_text") or False,
|
|
"flavor_text": face_payload.get("flavor_text") or False,
|
|
"power": face_payload.get("power") or False,
|
|
"toughness": face_payload.get("toughness") or False,
|
|
"loyalty": face_payload.get("loyalty") or False,
|
|
"artist": face_payload.get("artist") or False,
|
|
}
|
|
face = existing_faces.get(index)
|
|
if face:
|
|
face.with_context(
|
|
mvd_tcg_bypass_validated_write=True,
|
|
mvd_tcg_bypass_external_ref_write=True,
|
|
).write(values)
|
|
else:
|
|
face = self.env["mvd.tcg.mtg.card.face"].create(values)
|
|
kept_face_ids.append(face.id)
|
|
|
|
(
|
|
card.mtg_face_ids
|
|
- self.env["mvd.tcg.mtg.card.face"].browse(kept_face_ids)
|
|
).with_context(mvd_tcg_bypass_validated_write=True).unlink()
|
|
|
|
for payload in payloads or ():
|
|
card._mtg_scryfall_update_face_translations_from_payload(payload)
|
|
|
|
def _mtg_scryfall_sync_legalities(self, primary_payload):
|
|
"""Create or update legality rows from one primary Scryfall payload.
|
|
|
|
Args:
|
|
primary_payload: Canonical payload for the current print group.
|
|
|
|
Returns:
|
|
None: The legality rows are synchronized in place.
|
|
"""
|
|
self.ensure_one()
|
|
card = self.with_context(
|
|
mvd_tcg_bypass_validated_write=True,
|
|
mvd_tcg_bypass_external_ref_write=True,
|
|
)
|
|
|
|
legality_payload = primary_payload.get("legalities") or {}
|
|
format_records = self._mtg_scryfall_resolve_taxonomy_records(
|
|
"mvd.tcg.mtg.format",
|
|
legality_payload.keys(),
|
|
create_missing=False,
|
|
)
|
|
existing_legalities = {
|
|
legality.format_id.id: legality for legality in card.mtg_legality_ids
|
|
}
|
|
kept_legality_ids = []
|
|
|
|
for format_record in format_records:
|
|
status = (legality_payload.get(format_record.code) or "").strip().lower() or "not_legal"
|
|
values = {
|
|
"card_id": self.id,
|
|
"format_id": format_record.id,
|
|
"status": status,
|
|
}
|
|
legality = existing_legalities.get(format_record.id)
|
|
if legality:
|
|
legality.with_context(mvd_tcg_bypass_validated_write=True).write(
|
|
{"status": status}
|
|
)
|
|
else:
|
|
legality = self.env["mvd.tcg.mtg.card.legality"].create(values)
|
|
kept_legality_ids.append(legality.id)
|
|
|
|
(
|
|
card.mtg_legality_ids
|
|
- self.env["mvd.tcg.mtg.card.legality"].browse(kept_legality_ids)
|
|
).with_context(mvd_tcg_bypass_validated_write=True).unlink()
|
|
|
|
@api.depends(
|
|
"image_1920",
|
|
"mtg_scryfall_image_ids",
|
|
"mtg_scryfall_image_ids.language_code",
|
|
"mtg_scryfall_image_ids.image_1920",
|
|
)
|
|
@api.depends_context("lang")
|
|
def _compute_mtg_display_images(self):
|
|
"""Render the best localized card image for the current UI language.
|
|
|
|
Returns:
|
|
None: The compute updates records in place.
|
|
"""
|
|
for card in self:
|
|
localized_images = {
|
|
(image.language_code or "").strip().lower(): image.image_1920
|
|
for image in card.mtg_scryfall_image_ids
|
|
if image.image_1920
|
|
}
|
|
display_image = False
|
|
for language_code in card._mtg_scryfall_get_preferred_image_language_codes():
|
|
display_image = localized_images.get(language_code)
|
|
if display_image:
|
|
break
|
|
display_image = display_image or card.image_1920
|
|
card.mtg_display_image_1920 = display_image
|
|
card.mtg_display_image_512 = display_image
|
|
|
|
@api.model
|
|
def _mtg_scryfall_prepare_group_values(self, primary_payload, *, import_run=None):
|
|
"""Prepare ORM values for one localized Scryfall print group.
|
|
|
|
Args:
|
|
primary_payload: Canonical payload that drives the shared fields.
|
|
import_run: Optional import run record for traceability.
|
|
|
|
Returns:
|
|
dict: ORM values for create or write operations.
|
|
"""
|
|
mtg_game = self.env["mvd.tcg.game"]._mvd_tcg_get_mtg_game()
|
|
mtg_set = self.env["mvd.tcg.mtg.set"].mtg_scryfall_upsert_from_payload(
|
|
primary_payload,
|
|
import_run=import_run,
|
|
)
|
|
rarity = self.env["mvd.tcg.mtg.rarity"].search(
|
|
[("code", "=", (primary_payload.get("rarity") or "").strip().lower())],
|
|
limit=1,
|
|
)
|
|
color_codes = [
|
|
(color_code or "").strip().upper()
|
|
for color_code in (primary_payload.get("colors") or [])
|
|
if color_code
|
|
]
|
|
color_records = self.env["mvd.tcg.mtg.color"].search(
|
|
[("code", "in", color_codes)]
|
|
)
|
|
color_identity_codes = [
|
|
(color_code or "").strip().upper()
|
|
for color_code in (primary_payload.get("color_identity") or [])
|
|
if color_code
|
|
]
|
|
color_identity_records = self.env["mvd.tcg.mtg.color"].search(
|
|
[("code", "in", color_identity_codes)]
|
|
)
|
|
card_type_codes = self._mtg_scryfall_extract_card_type_codes(primary_payload)
|
|
card_type_records = self.env["mvd.tcg.mtg.card.type"].search(
|
|
[("code", "in", card_type_codes)]
|
|
)
|
|
keyword_display_names = {
|
|
self._mtg_scryfall_normalize_keyword_code(keyword_name): keyword_name
|
|
for keyword_name in (primary_payload.get("keywords") or [])
|
|
if self._mtg_scryfall_normalize_keyword_code(keyword_name)
|
|
}
|
|
keyword_records = self._mtg_scryfall_resolve_taxonomy_records(
|
|
"mvd.tcg.mtg.keyword",
|
|
keyword_display_names.keys(),
|
|
display_names=keyword_display_names,
|
|
create_missing=True,
|
|
)
|
|
platform_records = self._mtg_scryfall_resolve_taxonomy_records(
|
|
"mvd.tcg.mtg.platform",
|
|
primary_payload.get("games") or [],
|
|
)
|
|
finish_records = self._mtg_scryfall_resolve_taxonomy_records(
|
|
"mvd.tcg.mtg.finish",
|
|
primary_payload.get("finishes") or [],
|
|
)
|
|
|
|
values = {
|
|
"active": True,
|
|
"external_ref": self._mtg_scryfall_build_external_ref(primary_payload),
|
|
"game_id": mtg_game.id,
|
|
"state": "validated",
|
|
"mtg_scryfall_id": primary_payload.get("id") or False,
|
|
"mtg_scryfall_uri": primary_payload.get("scryfall_uri") or False,
|
|
"mtg_set_id": mtg_set.id,
|
|
"mtg_rarity_id": rarity.id or False,
|
|
"mtg_collector_number": primary_payload.get("collector_number") or False,
|
|
"mtg_oracle_id": primary_payload.get("oracle_id") or False,
|
|
"mtg_layout": primary_payload.get("layout") or False,
|
|
"mtg_mana_cost": primary_payload.get("mana_cost") or False,
|
|
"mtg_mana_value": primary_payload.get("cmc")
|
|
if primary_payload.get("cmc") is not None
|
|
else False,
|
|
"mtg_color_ids": [Command.set(color_records.ids)],
|
|
"mtg_color_identity_ids": [Command.set(color_identity_records.ids)],
|
|
"mtg_card_type_ids": [Command.set(card_type_records.ids)],
|
|
"mtg_keyword_ids": [Command.set(keyword_records.ids)],
|
|
"mtg_game_platform_ids": [Command.set(platform_records.ids)],
|
|
"mtg_finish_ids": [Command.set(finish_records.ids)],
|
|
"mtg_power": primary_payload.get("power") or False,
|
|
"mtg_toughness": primary_payload.get("toughness") or False,
|
|
"mtg_loyalty": primary_payload.get("loyalty") or False,
|
|
"mtg_artist": primary_payload.get("artist") or False,
|
|
"mtg_is_token": bool(
|
|
primary_payload.get("layout") == "token"
|
|
or primary_payload.get("set_type") == "token"
|
|
),
|
|
"mtg_is_reprint": bool(primary_payload.get("reprint")),
|
|
"mtg_is_promo": bool(primary_payload.get("promo")),
|
|
"mtg_is_digital": bool(primary_payload.get("digital")),
|
|
"mtg_is_full_art": bool(primary_payload.get("full_art")),
|
|
"mtg_is_textless": bool(primary_payload.get("textless")),
|
|
}
|
|
if import_run:
|
|
values.update(
|
|
{
|
|
"mtg_scryfall_last_import_run_id": import_run.id,
|
|
"mtg_scryfall_last_synced_at": fields.Datetime.now(),
|
|
}
|
|
)
|
|
return values
|
|
|
|
@api.model
|
|
def mtg_scryfall_upsert_group_from_payloads(self, payloads, import_run=None):
|
|
"""Create or update one MTG print group from localized payloads.
|
|
|
|
Args:
|
|
payloads: Raw localized Scryfall payloads for one print group.
|
|
import_run: Optional import run record for traceability.
|
|
|
|
Returns:
|
|
mvd.tcg.card: Upserted MTG card reference record.
|
|
"""
|
|
grouped_payloads = [
|
|
payload
|
|
for payload in (payloads or [])
|
|
if payload.get("object") == "card" and payload.get("id")
|
|
]
|
|
if not grouped_payloads:
|
|
return self.browse()
|
|
|
|
primary_payload = self._mtg_scryfall_select_primary_payload(grouped_payloads)
|
|
external_ref = self._mtg_scryfall_build_external_ref(primary_payload)
|
|
if not external_ref or external_ref == ":":
|
|
return self.browse()
|
|
|
|
mtg_game = self.env["mvd.tcg.game"]._mvd_tcg_get_mtg_game()
|
|
card = self.search(
|
|
[("game_id", "=", mtg_game.id), ("external_ref", "=", external_ref)],
|
|
limit=1,
|
|
)
|
|
values = self._mtg_scryfall_prepare_group_values(
|
|
primary_payload,
|
|
import_run=import_run,
|
|
)
|
|
should_write_primary_values = bool(
|
|
not card
|
|
or (primary_payload.get("lang") or "").strip().lower() in {"", "en"}
|
|
)
|
|
if should_write_primary_values:
|
|
values.update(
|
|
{
|
|
"name": primary_payload.get("name")
|
|
or primary_payload.get("printed_name")
|
|
or external_ref.upper(),
|
|
"mtg_type_line": primary_payload.get("type_line") or False,
|
|
"mtg_oracle_text": primary_payload.get("oracle_text") or False,
|
|
"mtg_flavor_text": primary_payload.get("flavor_text") or False,
|
|
}
|
|
)
|
|
|
|
localized_images = self._mtg_scryfall_collect_group_images(grouped_payloads)
|
|
image_base64 = (
|
|
localized_images.get((primary_payload.get("lang") or "").strip().lower())
|
|
or localized_images.get("en")
|
|
or self._mtg_scryfall_load_group_image_base64(grouped_payloads)
|
|
)
|
|
if image_base64 and (not card or not card.image_1920):
|
|
values["image_1920"] = image_base64
|
|
|
|
if card:
|
|
card = card.with_context(
|
|
mvd_tcg_bypass_validated_write=True,
|
|
mvd_tcg_bypass_external_ref_write=True,
|
|
)
|
|
card.write(values)
|
|
else:
|
|
if "name" not in values:
|
|
values["name"] = (
|
|
primary_payload.get("name")
|
|
or primary_payload.get("printed_name")
|
|
or external_ref.upper()
|
|
)
|
|
card = self.with_context(
|
|
mvd_tcg_bypass_external_ref_write=True,
|
|
).create(values)
|
|
|
|
for payload in grouped_payloads:
|
|
card._mtg_scryfall_update_translations_from_payload(payload)
|
|
card._mtg_scryfall_sync_faces_from_payloads(grouped_payloads)
|
|
card._mtg_scryfall_sync_legalities(primary_payload)
|
|
card._mtg_scryfall_sync_localized_images(localized_images)
|
|
return card
|
|
|
|
@api.model
|
|
def mtg_scryfall_upsert_from_payload(self, payload):
|
|
"""Create or update one MTG card reference from one Scryfall payload.
|
|
|
|
Args:
|
|
payload: Raw Scryfall card payload from the public API.
|
|
|
|
Returns:
|
|
mvd.tcg.card: Upserted MTG card reference record.
|
|
"""
|
|
return self.mtg_scryfall_upsert_group_from_payloads([payload])
|
|
|
|
def action_open_mtg_scryfall_last_import_run(self):
|
|
"""Open the most recent Scryfall import run linked to this card.
|
|
|
|
Returns:
|
|
dict | bool: Window action or ``False`` when no run is linked.
|
|
"""
|
|
self.ensure_one()
|
|
if not self.mtg_scryfall_last_import_run_id:
|
|
return False
|
|
|
|
return {
|
|
"type": "ir.actions.act_window",
|
|
"name": self.mtg_scryfall_last_import_run_id.display_name,
|
|
"res_model": "mvd.tcg.mtg.scryfall.import.run",
|
|
"view_mode": "form",
|
|
"res_id": self.mtg_scryfall_last_import_run_id.id,
|
|
"target": "current",
|
|
}
|
|
|
|
def action_mtg_scryfall_refresh_card(self):
|
|
"""Refresh the current MTG card from the Scryfall connector.
|
|
|
|
Returns:
|
|
dict: Window action for the created refresh run.
|
|
"""
|
|
self.ensure_one()
|
|
self.env["mvd.tcg.mtg.scryfall.api"]._mtg_scryfall_check_manager_access()
|
|
refresh_run = self.env["mvd.tcg.mtg.scryfall.import.run"].create_card_refresh_run(
|
|
self
|
|
)
|
|
return refresh_run.action_execute_import()
|