481 lines
16 KiB
Python
481 lines
16 KiB
Python
import logging
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime
|
|
from typing import List, Dict, Any, Type, Optional, Tuple
|
|
|
|
from .utils import parse_date
|
|
|
|
logger = logging.getLogger("StoreApiModels")
|
|
|
|
# lk: Typing overloads for unimplemented types
|
|
DieselSocialLinks = Dict
|
|
|
|
CatalogNamespaceModel = Dict
|
|
CategoryModel = Dict
|
|
CustomAttributeModel = Dict
|
|
ItemModel = Dict
|
|
SellerModel = Dict
|
|
PageSandboxModel = Dict
|
|
TagModel = Dict
|
|
|
|
|
|
@dataclass
|
|
class ImageUrlModel:
|
|
type: Optional[str] = None
|
|
url: Optional[str] = None
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
tmp: Dict[str, Any] = {}
|
|
tmp.update({})
|
|
if self.type is not None:
|
|
tmp["type"] = self.type
|
|
if self.url is not None:
|
|
tmp["url"] = self.url
|
|
return tmp
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["ImageUrlModel"], src: Dict[str, Any]) -> "ImageUrlModel":
|
|
d = src.copy()
|
|
type = d.pop("type", None)
|
|
url = d.pop("url", None)
|
|
tmp = cls(type=type, url=url)
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class KeyImagesModel:
|
|
key_images: Optional[List[ImageUrlModel]] = None
|
|
tall_types = ("DieselStoreFrontTall", "OfferImageTall", "Thumbnail", "ProductLogo", "DieselGameBoxLogo")
|
|
wide_types = ("DieselStoreFrontWide", "OfferImageWide", "VaultClosed", "ProductLogo")
|
|
|
|
def __getitem__(self, item):
|
|
return self.key_images[item]
|
|
|
|
def __bool__(self):
|
|
return bool(self.key_images)
|
|
|
|
def to_list(self) -> List[Dict[str, Any]]:
|
|
items: Optional[List[Dict[str, Any]]] = None
|
|
if self.key_images is not None:
|
|
items = []
|
|
for image_url in self.key_images:
|
|
item = image_url.to_dict()
|
|
items.append(item)
|
|
return items
|
|
|
|
@classmethod
|
|
def from_list(cls: Type["KeyImagesModel"], src: List[Dict]):
|
|
d = src.copy()
|
|
key_images = []
|
|
for item in d:
|
|
image_url = ImageUrlModel.from_dict(item)
|
|
key_images.append(image_url)
|
|
tmp = cls(key_images)
|
|
return tmp
|
|
|
|
def available_tall(self) -> List[ImageUrlModel]:
|
|
tall_images = filter(lambda img: img.type in KeyImagesModel.tall_types, self.key_images)
|
|
tall_images = sorted(tall_images, key=lambda x: KeyImagesModel.tall_types.index(x.type))
|
|
return tall_images
|
|
|
|
def available_wide(self) -> List[ImageUrlModel]:
|
|
wide_images = filter(lambda img: img.type in KeyImagesModel.wide_types, self.key_images)
|
|
wide_images = sorted(wide_images, key=lambda x: KeyImagesModel.wide_types.index(x.type))
|
|
return wide_images
|
|
|
|
def for_dimensions(self, w: int, h: int) -> ImageUrlModel:
|
|
try:
|
|
if w > h:
|
|
model = self.available_wide()[0]
|
|
else:
|
|
model = self.available_tall()[0]
|
|
_ = model.url
|
|
except Exception as e:
|
|
logger.error(e)
|
|
logger.error(self.to_list())
|
|
else:
|
|
return model
|
|
|
|
|
|
CurrencyModel = Dict
|
|
FormattedPriceModel = Dict
|
|
LineOffersModel = Dict
|
|
|
|
|
|
@dataclass
|
|
class TotalPriceModel:
|
|
discountPrice: Optional[int] = None
|
|
originalPrice: Optional[int] = None
|
|
voucherDiscount: Optional[int] = None
|
|
discount: Optional[int] = None
|
|
currencyCode: Optional[str] = None
|
|
currencyInfo: Optional[CurrencyModel] = None
|
|
fmtPrice: Optional[FormattedPriceModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["TotalPriceModel"], src: Dict[str, Any]) -> "TotalPriceModel":
|
|
d = src.copy()
|
|
tmp = cls(
|
|
discountPrice=d.pop("discountPrice", None),
|
|
originalPrice=d.pop("originalPrice", None),
|
|
voucherDiscount=d.pop("voucherDiscount", None),
|
|
discount=d.pop("discount", None),
|
|
currencyCode=d.pop("currencyCode", None),
|
|
currencyInfo=d.pop("currrencyInfo", {}),
|
|
fmtPrice=d.pop("fmtPrice", {}),
|
|
)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class GetPriceResModel:
|
|
totalPrice: Optional[TotalPriceModel] = None
|
|
lineOffers: Optional[LineOffersModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["GetPriceResModel"], src: Dict[str, Any]) -> "GetPriceResModel":
|
|
d = src.copy()
|
|
total_price = TotalPriceModel.from_dict(x) if (x := d.pop("totalPrice", {})) else None
|
|
tmp = cls(totalPrice=total_price, lineOffers=d.pop("lineOffers", {}))
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
DiscountSettingModel = Dict
|
|
|
|
|
|
@dataclass
|
|
class PromotionalOfferModel:
|
|
startDate: Optional[datetime] = None
|
|
endDate: Optional[datetime] = None
|
|
discountSetting: Optional[DiscountSettingModel] = None
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["PromotionalOfferModel"], src: Dict[str, Any]) -> "PromotionalOfferModel":
|
|
d = src.copy()
|
|
start_date = parse_date(x) if (x := d.pop("startDate", "")) else None
|
|
end_date = parse_date(x) if (x := d.pop("endDate", "")) else None
|
|
tmp = cls(startDate=start_date, endDate=end_date, discountSetting=d.pop("discountSetting", {}))
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class PromotionalOffersModel:
|
|
promotionalOffers: Optional[Tuple[PromotionalOfferModel]] = None
|
|
|
|
@classmethod
|
|
def from_list(cls: Type["PromotionalOffersModel"], src: Dict[str, List]) -> "PromotionalOffersModel":
|
|
d = src.copy()
|
|
promotional_offers = (
|
|
tuple([PromotionalOfferModel.from_dict(y) for y in x]) if (x := d.pop("promotionalOffers", [])) else None
|
|
)
|
|
tmp = cls(promotionalOffers=promotional_offers)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class PromotionsModel:
|
|
promotionalOffers: Optional[Tuple[PromotionalOffersModel]] = None
|
|
upcomingPromotionalOffers: Optional[Tuple[PromotionalOffersModel]] = None
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["PromotionsModel"], src: Dict[str, Any]) -> "PromotionsModel":
|
|
d = src.copy()
|
|
promotional_offers = (
|
|
tuple([PromotionalOffersModel.from_list(y) for y in x]) if (x := d.pop("promotionalOffers", [])) else None
|
|
)
|
|
upcoming_promotional_offers = (
|
|
tuple([PromotionalOffersModel.from_list(y) for y in x])
|
|
if (x := d.pop("upcomingPromotionalOffers", []))
|
|
else None
|
|
)
|
|
tmp = cls(promotionalOffers=promotional_offers, upcomingPromotionalOffers=upcoming_promotional_offers)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class CatalogOfferModel:
|
|
catalogNs: Optional[CatalogNamespaceModel] = None
|
|
categories: Optional[List[CategoryModel]] = None
|
|
customAttributes: Optional[List[CustomAttributeModel]] = None
|
|
description: Optional[str] = None
|
|
effectiveDate: Optional[datetime] = None
|
|
expiryDate: Optional[datetime] = None
|
|
id: Optional[str] = None
|
|
isCodeRedemptionOnly: Optional[bool] = None
|
|
items: Optional[List[ItemModel]] = None
|
|
keyImages: Optional[KeyImagesModel] = None
|
|
namespace: Optional[str] = None
|
|
offerMappings: Optional[List[PageSandboxModel]] = None
|
|
offerType: Optional[str] = None
|
|
price: Optional[GetPriceResModel] = None
|
|
productSlug: Optional[str] = None
|
|
promotions: Optional[PromotionsModel] = None
|
|
seller: Optional[SellerModel] = None
|
|
status: Optional[str] = None
|
|
tags: Optional[List[TagModel]] = None
|
|
title: Optional[str] = None
|
|
url: Optional[str] = None
|
|
urlSlug: Optional[str] = None
|
|
viewableDate: Optional[datetime] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["CatalogOfferModel"], src: Dict[str, Any]) -> "CatalogOfferModel":
|
|
d = src.copy()
|
|
effective_date = parse_date(x) if (x := d.pop("effectiveDate", "")) else None
|
|
expiry_date = parse_date(x) if (x := d.pop("expiryDate", "")) else None
|
|
key_images = KeyImagesModel.from_list(d.pop("keyImages", []))
|
|
price = GetPriceResModel.from_dict(x) if (x := d.pop("price", {})) else None
|
|
promotions = PromotionsModel.from_dict(x) if (x := d.pop("promotions", {})) else None
|
|
viewable_date = parse_date(x) if (x := d.pop("viewableDate", "")) else None
|
|
tmp = cls(
|
|
catalogNs=d.pop("catalogNs", {}),
|
|
categories=d.pop("categories", []),
|
|
customAttributes=d.pop("customAttributes", []),
|
|
description=d.pop("description", ""),
|
|
effectiveDate=effective_date,
|
|
expiryDate=expiry_date,
|
|
id=d.pop("id", ""),
|
|
isCodeRedemptionOnly=d.pop("isCodeRedemptionOnly", None),
|
|
items=d.pop("items", []),
|
|
keyImages=key_images,
|
|
namespace=d.pop("namespace", ""),
|
|
offerMappings=d.pop("offerMappings", []),
|
|
offerType=d.pop("offerType", ""),
|
|
price=price,
|
|
productSlug=d.pop("productSlug", ""),
|
|
promotions=promotions,
|
|
seller=d.pop("seller", {}),
|
|
status=d.pop("status", ""),
|
|
tags=d.pop("tags", []),
|
|
title=d.pop("title", ""),
|
|
url=d.pop("url", ""),
|
|
urlSlug=d.pop("urlSlug", ""),
|
|
viewableDate=viewable_date,
|
|
)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class WishlistItemModel:
|
|
created: Optional[datetime] = None
|
|
id: Optional[str] = None
|
|
namespace: Optional[str] = None
|
|
isFirstTime: Optional[bool] = None
|
|
offerId: Optional[str] = None
|
|
order: Optional[Any] = None
|
|
updated: Optional[datetime] = None
|
|
offer: Optional[CatalogOfferModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["WishlistItemModel"], src: Dict[str, Any]) -> "WishlistItemModel":
|
|
d = src.copy()
|
|
created = parse_date(x) if (x := d.pop("created", "")) else None
|
|
offer = CatalogOfferModel.from_dict(x) if (x := d.pop("offer", {})) else None
|
|
updated = parse_date(x) if (x := d.pop("updated", "")) else None
|
|
tmp = cls(
|
|
created=created,
|
|
id=d.pop("id", ""),
|
|
namespace=d.pop("namespace", ""),
|
|
isFirstTime=d.pop("isFirstTime", None),
|
|
offerId=d.pop("offerId", ""),
|
|
order=d.pop("order", ""),
|
|
updated=updated,
|
|
offer=offer,
|
|
)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class PagingModel:
|
|
count: Optional[int] = None
|
|
total: Optional[int] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["PagingModel"], src: Dict[str, Any]) -> "PagingModel":
|
|
d = src.copy()
|
|
count = d.pop("count", None)
|
|
total = d.pop("total", None)
|
|
tmp = cls(count=count, total=total)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class SearchStoreModel:
|
|
elements: Optional[List[CatalogOfferModel]] = None
|
|
paging: Optional[PagingModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["SearchStoreModel"], src: Dict[str, Any]) -> "SearchStoreModel":
|
|
d = src.copy()
|
|
_elements = d.pop("elements", [])
|
|
elements = [] if _elements else None
|
|
for item in _elements:
|
|
elem = CatalogOfferModel.from_dict(item)
|
|
elements.append(elem)
|
|
paging = PagingModel.from_dict(x) if (x := d.pop("paging", {})) else None
|
|
tmp = cls(elements=elements, paging=paging)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class CatalogModel:
|
|
searchStore: Optional[SearchStoreModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["CatalogModel"], src: Dict[str, Any]) -> "CatalogModel":
|
|
d = src.copy()
|
|
search_store = SearchStoreModel.from_dict(x) if (x := d.pop("searchStore", {})) else None
|
|
tmp = cls(searchStore=search_store)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class WishlistItemsModel:
|
|
elements: Optional[List[WishlistItemModel]] = None
|
|
paging: Optional[PagingModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["WishlistItemsModel"], src: Dict[str, Any]) -> "WishlistItemsModel":
|
|
d = src.copy()
|
|
_elements = d.pop("elements", [])
|
|
elements = [] if _elements else None
|
|
for item in _elements:
|
|
elem = WishlistItemModel.from_dict(item)
|
|
elements.append(elem)
|
|
paging = PagingModel.from_dict(x) if (x := d.pop("paging", {})) else None
|
|
tmp = cls(elements=elements, paging=paging)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class RemoveFromWishlistModel:
|
|
success: Optional[bool] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["RemoveFromWishlistModel"], src: Dict[str, Any]) -> "RemoveFromWishlistModel":
|
|
d = src.copy()
|
|
tmp = cls(success=d.pop("success", None))
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class AddToWishlistModel:
|
|
wishlistItem: Optional[WishlistItemModel] = None
|
|
success: Optional[bool] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["AddToWishlistModel"], src: Dict[str, Any]) -> "AddToWishlistModel":
|
|
d = src.copy()
|
|
wishlist_item = WishlistItemModel.from_dict(x) if (x := d.pop("wishlistItem", {})) else None
|
|
tmp = cls(wishlistItem=wishlist_item, success=d.pop("success", None))
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class WishlistModel:
|
|
wishlistItems: Optional[WishlistItemsModel] = None
|
|
removeFromWishlist: Optional[RemoveFromWishlistModel] = None
|
|
addToWishlist: Optional[AddToWishlistModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["WishlistModel"], src: Dict[str, Any]) -> "WishlistModel":
|
|
d = src.copy()
|
|
wishlist_items = WishlistItemsModel.from_dict(x) if (x := d.pop("wishlistItems", {})) else None
|
|
remove_from_wishlist = RemoveFromWishlistModel.from_dict(x) if (x := d.pop("removeFromWishlist", {})) else None
|
|
add_to_wishlist = AddToWishlistModel.from_dict(x) if (x := d.pop("addToWishlist", {})) else None
|
|
tmp = cls(
|
|
wishlistItems=wishlist_items, removeFromWishlist=remove_from_wishlist, addToWishlist=add_to_wishlist
|
|
)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
ProductModel = Dict
|
|
|
|
|
|
@dataclass
|
|
class DataModel:
|
|
product: Optional[ProductModel] = None
|
|
catalog: Optional[CatalogModel] = None
|
|
wishlist: Optional[WishlistModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["DataModel"], src: Dict[str, Any]) -> "DataModel":
|
|
d = src.copy()
|
|
catalog = CatalogModel.from_dict(x) if (x := d.pop("Catalog", {})) else None
|
|
wishlist = WishlistModel.from_dict(x) if (x := d.pop("Wishlist", {})) else None
|
|
tmp = cls(product=d.pop("Product", {}), catalog=catalog, wishlist=wishlist)
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class ErrorModel:
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["ErrorModel"], src: Dict[str, Any]) -> "ErrorModel":
|
|
d = src.copy()
|
|
tmp = cls()
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class ExtensionsModel:
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["ExtensionsModel"], src: Dict[str, Any]) -> "ExtensionsModel":
|
|
d = src.copy()
|
|
tmp = cls()
|
|
tmp.unmapped = d
|
|
return tmp
|
|
|
|
|
|
@dataclass
|
|
class ResponseModel:
|
|
data: Optional[DataModel] = None
|
|
errors: Optional[List[ErrorModel]] = None
|
|
extensions: Optional[ExtensionsModel] = None
|
|
unmapped: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type["ResponseModel"], src: Dict[str, Any]) -> "ResponseModel":
|
|
d = src.copy()
|
|
data = DataModel.from_dict(x) if (x := d.pop("data", {})) else None
|
|
_errors = d.pop("errors", [])
|
|
errors = [] if _errors else None
|
|
for item in _errors:
|
|
error = ErrorModel.from_dict(item)
|
|
errors.append(error)
|
|
extensions = ExtensionsModel.from_dict(x) if (x := d.pop("extensions", {})) else None
|
|
tmp = cls(data=data, errors=errors, extensions=extensions)
|
|
tmp.unmapped = d
|
|
return tmp
|