SymfWebAPI 1.26.10.1__py3-none-any.whl

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductDimensions2Controller/_common.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/v2/ProductDimensions')
+def _prepare_Get(*, productCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productCode"] = productCode
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductDimensions2Controller/_ops.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.FKF.Common.ViewModels import Dimension
+
+_ADAPTER_Get = TypeAdapter(List[Dimension])
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[Dimension]]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/v2/ProductDimensions', parser=_parse_Get)

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductDimensionsController/__init__.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.FKF.Common.ViewModels import Dimension
+from ._common import (
+    _prepare_Get,
+    _prepare_Update,
+)
+from ._ops import (
+    OP_Get,
+    OP_Update,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, productCode: str) -> ResponseEnvelope[List[Dimension]]: ...
+@overload
+def Get(api: SyncRequestProtocol, productCode: str) -> ResponseEnvelope[List[Dimension]]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, productCode: str) -> Awaitable[ResponseEnvelope[List[Dimension]]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, productCode: str) -> Awaitable[ResponseEnvelope[List[Dimension]]]: ...
+def Get(api: object, productCode: str) -> ResponseEnvelope[List[Dimension]] | Awaitable[ResponseEnvelope[List[Dimension]]]:
+    params, data = _prepare_Get(productCode=productCode)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+@overload
+def Update(api: SyncInvokerProtocol, productCode: str, productDimensions: List["Dimension"]) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, productCode: str, productDimensions: List["Dimension"]) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, productCode: str, productDimensions: List["Dimension"]) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, productCode: str, productDimensions: List["Dimension"]) -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, productCode: str, productDimensions: List["Dimension"]) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(productCode=productCode, productDimensions=productDimensions)
+    return invoke_operation(api, OP_Update, params=params, data=data)
+
+__all__ = ["Get", "Update"]

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductDimensionsController/_common.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any
+
+import json
+
+_REQUEST_Get = ('GET', '/api/ProductDimensions')
+def _prepare_Get(*, productCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productCode"] = productCode
+    data = None
+    return params or None, data
+
+_REQUEST_Update = ('PUT', '/api/ProductDimensions/UpdateList')
+def _prepare_Update(*, productCode, productDimensions) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productCode"] = productCode
+    data = json.dumps(productDimensions) if productDimensions is not None else None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductDimensionsController/_ops.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.FKF.Common.ViewModels import Dimension
+
+_ADAPTER_Get = TypeAdapter(List[Dimension])
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[Dimension]]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/ProductDimensions', parser=_parse_Get)
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/ProductDimensions/UpdateList', parser=_parse_Update)

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductPhotosController/__init__.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Awaitable, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductPhoto
+from SymfWebAPI.WebAPI.Interface.Enums import enumPhotoQuality
+from ._common import (
+    _prepare_Get,
+)
+from ._ops import (
+    OP_Get,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, photoId: int, quality: "enumPhotoQuality") -> ResponseEnvelope[ProductPhoto]: ...
+@overload
+def Get(api: SyncRequestProtocol, photoId: int, quality: "enumPhotoQuality") -> ResponseEnvelope[ProductPhoto]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, photoId: int, quality: "enumPhotoQuality") -> Awaitable[ResponseEnvelope[ProductPhoto]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, photoId: int, quality: "enumPhotoQuality") -> Awaitable[ResponseEnvelope[ProductPhoto]]: ...
+def Get(api: object, photoId: int, quality: "enumPhotoQuality") -> ResponseEnvelope[ProductPhoto] | Awaitable[ResponseEnvelope[ProductPhoto]]:
+    params, data = _prepare_Get(photoId=photoId, quality=quality)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+__all__ = ["Get"]

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductPhotosController/_common.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/ProductPhotos')
+def _prepare_Get(*, photoId, quality) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["photoId"] = photoId
+    params["quality"] = quality.value
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductPhotosController/_ops.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductPhoto
+from SymfWebAPI.WebAPI.Interface.Enums import enumPhotoQuality
+
+_ADAPTER_Get = TypeAdapter(ProductPhoto)
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[ProductPhoto]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/ProductPhotos', parser=_parse_Get)

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductPricesController/__init__.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import IndividualDiscount
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.PriceCalculations import PriceCalculationCriteria
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.PriceCalculations import PriceCalculationResult
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import PriceFactor
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import PriceFactorCriteria
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.PriceCalculations import PriceOrderCriteria
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.PriceCalculations import PriceOrderResult
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import ProductPriceListElement
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import ProductPricesEdit
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import ProductSalePriceBase
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import QuantitativeDiscount
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import QuantitativeDiscountListElement
+from ._common import (
+    _prepare_Update,
+    _prepare_Recalculate,
+    _prepare_GetSalePricesByProduct,
+    _prepare_GetSalePricesByProductKind,
+    _prepare_GetQuantitativeDiscountsByProduct,
+    _prepare_GetQuantitativeDiscountsByProductKind,
+    _prepare_GetIndividualDiscountsByContractor,
+    _prepare_GetIndividualDiscountsByContractorKind,
+    _prepare_GetPriceFactors,
+    _prepare_CalculatePrices,
+    _prepare_OrderPrices,
+)
+from ._ops import (
+    OP_Update,
+    OP_Recalculate,
+    OP_GetSalePricesByProduct,
+    OP_GetSalePricesByProductKind,
+    OP_GetQuantitativeDiscountsByProduct,
+    OP_GetQuantitativeDiscountsByProductKind,
+    OP_GetIndividualDiscountsByContractor,
+    OP_GetIndividualDiscountsByContractorKind,
+    OP_GetPriceFactors,
+    OP_CalculatePrices,
+    OP_OrderPrices,
+)
+
+@overload
+def Update(api: SyncInvokerProtocol, productCode: str, prices: "ProductPricesEdit") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, productCode: str, prices: "ProductPricesEdit") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, productCode: str, prices: "ProductPricesEdit") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, productCode: str, prices: "ProductPricesEdit") -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, productCode: str, prices: "ProductPricesEdit") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(productCode=productCode, prices=prices)
+    return invoke_operation(api, OP_Update, params=params, data=data)
+
+@overload
+def Recalculate(api: SyncInvokerProtocol, productCode: str) -> ResponseEnvelope[None]: ...
+@overload
+def Recalculate(api: SyncRequestProtocol, productCode: str) -> ResponseEnvelope[None]: ...
+@overload
+def Recalculate(api: AsyncInvokerProtocol, productCode: str) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Recalculate(api: AsyncRequestProtocol, productCode: str) -> Awaitable[ResponseEnvelope[None]]: ...
+def Recalculate(api: object, productCode: str) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Recalculate(productCode=productCode)
+    return invoke_operation(api, OP_Recalculate, params=params, data=data)
+
+@overload
+def GetSalePricesByProduct(api: SyncInvokerProtocol, productCode: str) -> ResponseEnvelope[List[ProductSalePriceBase]]: ...
+@overload
+def GetSalePricesByProduct(api: SyncRequestProtocol, productCode: str) -> ResponseEnvelope[List[ProductSalePriceBase]]: ...
+@overload
+def GetSalePricesByProduct(api: AsyncInvokerProtocol, productCode: str) -> Awaitable[ResponseEnvelope[List[ProductSalePriceBase]]]: ...
+@overload
+def GetSalePricesByProduct(api: AsyncRequestProtocol, productCode: str) -> Awaitable[ResponseEnvelope[List[ProductSalePriceBase]]]: ...
+def GetSalePricesByProduct(api: object, productCode: str) -> ResponseEnvelope[List[ProductSalePriceBase]] | Awaitable[ResponseEnvelope[List[ProductSalePriceBase]]]:
+    params, data = _prepare_GetSalePricesByProduct(productCode=productCode)
+    return invoke_operation(api, OP_GetSalePricesByProduct, params=params, data=data)
+
+@overload
+def GetSalePricesByProductKind(api: SyncInvokerProtocol, productKindId: int) -> ResponseEnvelope[List[ProductPriceListElement]]: ...
+@overload
+def GetSalePricesByProductKind(api: SyncRequestProtocol, productKindId: int) -> ResponseEnvelope[List[ProductPriceListElement]]: ...
+@overload
+def GetSalePricesByProductKind(api: AsyncInvokerProtocol, productKindId: int) -> Awaitable[ResponseEnvelope[List[ProductPriceListElement]]]: ...
+@overload
+def GetSalePricesByProductKind(api: AsyncRequestProtocol, productKindId: int) -> Awaitable[ResponseEnvelope[List[ProductPriceListElement]]]: ...
+def GetSalePricesByProductKind(api: object, productKindId: int) -> ResponseEnvelope[List[ProductPriceListElement]] | Awaitable[ResponseEnvelope[List[ProductPriceListElement]]]:
+    params, data = _prepare_GetSalePricesByProductKind(productKindId=productKindId)
+    return invoke_operation(api, OP_GetSalePricesByProductKind, params=params, data=data)
+
+@overload
+def GetQuantitativeDiscountsByProduct(api: SyncInvokerProtocol, productCode: str) -> ResponseEnvelope[List[QuantitativeDiscount]]: ...
+@overload
+def GetQuantitativeDiscountsByProduct(api: SyncRequestProtocol, productCode: str) -> ResponseEnvelope[List[QuantitativeDiscount]]: ...
+@overload
+def GetQuantitativeDiscountsByProduct(api: AsyncInvokerProtocol, productCode: str) -> Awaitable[ResponseEnvelope[List[QuantitativeDiscount]]]: ...
+@overload
+def GetQuantitativeDiscountsByProduct(api: AsyncRequestProtocol, productCode: str) -> Awaitable[ResponseEnvelope[List[QuantitativeDiscount]]]: ...
+def GetQuantitativeDiscountsByProduct(api: object, productCode: str) -> ResponseEnvelope[List[QuantitativeDiscount]] | Awaitable[ResponseEnvelope[List[QuantitativeDiscount]]]:
+    params, data = _prepare_GetQuantitativeDiscountsByProduct(productCode=productCode)
+    return invoke_operation(api, OP_GetQuantitativeDiscountsByProduct, params=params, data=data)
+
+@overload
+def GetQuantitativeDiscountsByProductKind(api: SyncInvokerProtocol, productKindId: int) -> ResponseEnvelope[List[QuantitativeDiscountListElement]]: ...
+@overload
+def GetQuantitativeDiscountsByProductKind(api: SyncRequestProtocol, productKindId: int) -> ResponseEnvelope[List[QuantitativeDiscountListElement]]: ...
+@overload
+def GetQuantitativeDiscountsByProductKind(api: AsyncInvokerProtocol, productKindId: int) -> Awaitable[ResponseEnvelope[List[QuantitativeDiscountListElement]]]: ...
+@overload
+def GetQuantitativeDiscountsByProductKind(api: AsyncRequestProtocol, productKindId: int) -> Awaitable[ResponseEnvelope[List[QuantitativeDiscountListElement]]]: ...
+def GetQuantitativeDiscountsByProductKind(api: object, productKindId: int) -> ResponseEnvelope[List[QuantitativeDiscountListElement]] | Awaitable[ResponseEnvelope[List[QuantitativeDiscountListElement]]]:
+    params, data = _prepare_GetQuantitativeDiscountsByProductKind(productKindId=productKindId)
+    return invoke_operation(api, OP_GetQuantitativeDiscountsByProductKind, params=params, data=data)
+
+@overload
+def GetIndividualDiscountsByContractor(api: SyncInvokerProtocol, contractorCode: str) -> ResponseEnvelope[List[IndividualDiscount]]: ...
+@overload
+def GetIndividualDiscountsByContractor(api: SyncRequestProtocol, contractorCode: str) -> ResponseEnvelope[List[IndividualDiscount]]: ...
+@overload
+def GetIndividualDiscountsByContractor(api: AsyncInvokerProtocol, contractorCode: str) -> Awaitable[ResponseEnvelope[List[IndividualDiscount]]]: ...
+@overload
+def GetIndividualDiscountsByContractor(api: AsyncRequestProtocol, contractorCode: str) -> Awaitable[ResponseEnvelope[List[IndividualDiscount]]]: ...
+def GetIndividualDiscountsByContractor(api: object, contractorCode: str) -> ResponseEnvelope[List[IndividualDiscount]] | Awaitable[ResponseEnvelope[List[IndividualDiscount]]]:
+    params, data = _prepare_GetIndividualDiscountsByContractor(contractorCode=contractorCode)
+    return invoke_operation(api, OP_GetIndividualDiscountsByContractor, params=params, data=data)
+
+@overload
+def GetIndividualDiscountsByContractorKind(api: SyncInvokerProtocol, contractorKindId: int) -> ResponseEnvelope[List[IndividualDiscount]]: ...
+@overload
+def GetIndividualDiscountsByContractorKind(api: SyncRequestProtocol, contractorKindId: int) -> ResponseEnvelope[List[IndividualDiscount]]: ...
+@overload
+def GetIndividualDiscountsByContractorKind(api: AsyncInvokerProtocol, contractorKindId: int) -> Awaitable[ResponseEnvelope[List[IndividualDiscount]]]: ...
+@overload
+def GetIndividualDiscountsByContractorKind(api: AsyncRequestProtocol, contractorKindId: int) -> Awaitable[ResponseEnvelope[List[IndividualDiscount]]]: ...
+def GetIndividualDiscountsByContractorKind(api: object, contractorKindId: int) -> ResponseEnvelope[List[IndividualDiscount]] | Awaitable[ResponseEnvelope[List[IndividualDiscount]]]:
+    params, data = _prepare_GetIndividualDiscountsByContractorKind(contractorKindId=contractorKindId)
+    return invoke_operation(api, OP_GetIndividualDiscountsByContractorKind, params=params, data=data)
+
+@overload
+def GetPriceFactors(api: SyncInvokerProtocol, criteria: "PriceFactorCriteria") -> ResponseEnvelope[List[PriceFactor]]: ...
+@overload
+def GetPriceFactors(api: SyncRequestProtocol, criteria: "PriceFactorCriteria") -> ResponseEnvelope[List[PriceFactor]]: ...
+@overload
+def GetPriceFactors(api: AsyncInvokerProtocol, criteria: "PriceFactorCriteria") -> Awaitable[ResponseEnvelope[List[PriceFactor]]]: ...
+@overload
+def GetPriceFactors(api: AsyncRequestProtocol, criteria: "PriceFactorCriteria") -> Awaitable[ResponseEnvelope[List[PriceFactor]]]: ...
+def GetPriceFactors(api: object, criteria: "PriceFactorCriteria") -> ResponseEnvelope[List[PriceFactor]] | Awaitable[ResponseEnvelope[List[PriceFactor]]]:
+    params, data = _prepare_GetPriceFactors(criteria=criteria)
+    return invoke_operation(api, OP_GetPriceFactors, params=params, data=data)
+
+@overload
+def CalculatePrices(api: SyncInvokerProtocol, criteria: "PriceCalculationCriteria") -> ResponseEnvelope[PriceCalculationResult]: ...
+@overload
+def CalculatePrices(api: SyncRequestProtocol, criteria: "PriceCalculationCriteria") -> ResponseEnvelope[PriceCalculationResult]: ...
+@overload
+def CalculatePrices(api: AsyncInvokerProtocol, criteria: "PriceCalculationCriteria") -> Awaitable[ResponseEnvelope[PriceCalculationResult]]: ...
+@overload
+def CalculatePrices(api: AsyncRequestProtocol, criteria: "PriceCalculationCriteria") -> Awaitable[ResponseEnvelope[PriceCalculationResult]]: ...
+def CalculatePrices(api: object, criteria: "PriceCalculationCriteria") -> ResponseEnvelope[PriceCalculationResult] | Awaitable[ResponseEnvelope[PriceCalculationResult]]:
+    params, data = _prepare_CalculatePrices(criteria=criteria)
+    return invoke_operation(api, OP_CalculatePrices, params=params, data=data)
+
+@overload
+def OrderPrices(api: SyncInvokerProtocol, criteria: "PriceOrderCriteria") -> ResponseEnvelope[PriceOrderResult]: ...
+@overload
+def OrderPrices(api: SyncRequestProtocol, criteria: "PriceOrderCriteria") -> ResponseEnvelope[PriceOrderResult]: ...
+@overload
+def OrderPrices(api: AsyncInvokerProtocol, criteria: "PriceOrderCriteria") -> Awaitable[ResponseEnvelope[PriceOrderResult]]: ...
+@overload
+def OrderPrices(api: AsyncRequestProtocol, criteria: "PriceOrderCriteria") -> Awaitable[ResponseEnvelope[PriceOrderResult]]: ...
+def OrderPrices(api: object, criteria: "PriceOrderCriteria") -> ResponseEnvelope[PriceOrderResult] | Awaitable[ResponseEnvelope[PriceOrderResult]]:
+    params, data = _prepare_OrderPrices(criteria=criteria)
+    return invoke_operation(api, OP_OrderPrices, params=params, data=data)
+
+__all__ = ["Update", "Recalculate", "GetSalePricesByProduct", "GetSalePricesByProductKind", "GetQuantitativeDiscountsByProduct", "GetQuantitativeDiscountsByProductKind", "GetIndividualDiscountsByContractor", "GetIndividualDiscountsByContractorKind", "GetPriceFactors", "CalculatePrices", "OrderPrices"]

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductPricesController/_common.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Update = ('PUT', '/api/ProductPrices/Update')
+def _prepare_Update(*, productCode, prices) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productCode"] = productCode
+    data = prices.model_dump_json(exclude_unset=True) if prices is not None else None
+    return params or None, data
+
+_REQUEST_Recalculate = ('PATCH', '/api/ProductPrices/Recalculate')
+def _prepare_Recalculate(*, productCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productCode"] = productCode
+    data = None
+    return params or None, data
+
+_REQUEST_GetSalePricesByProduct = ('GET', '/api/ProductPrices/SalePrices')
+def _prepare_GetSalePricesByProduct(*, productCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productCode"] = productCode
+    data = None
+    return params or None, data
+
+_REQUEST_GetSalePricesByProductKind = ('GET', '/api/ProductPrices/SalePrices')
+def _prepare_GetSalePricesByProductKind(*, productKindId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productKindId"] = productKindId
+    data = None
+    return params or None, data
+
+_REQUEST_GetQuantitativeDiscountsByProduct = ('GET', '/api/ProductPrices/QuantitativeDiscounts')
+def _prepare_GetQuantitativeDiscountsByProduct(*, productCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productCode"] = productCode
+    data = None
+    return params or None, data
+
+_REQUEST_GetQuantitativeDiscountsByProductKind = ('GET', '/api/ProductPrices/QuantitativeDiscounts')
+def _prepare_GetQuantitativeDiscountsByProductKind(*, productKindId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productKindId"] = productKindId
+    data = None
+    return params or None, data
+
+_REQUEST_GetIndividualDiscountsByContractor = ('GET', '/api/ProductPrices/IndividualDiscounts')
+def _prepare_GetIndividualDiscountsByContractor(*, contractorCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractorCode"] = contractorCode
+    data = None
+    return params or None, data
+
+_REQUEST_GetIndividualDiscountsByContractorKind = ('GET', '/api/ProductPrices/IndividualDiscounts')
+def _prepare_GetIndividualDiscountsByContractorKind(*, contractorKindId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractorKindId"] = contractorKindId
+    data = None
+    return params or None, data
+
+_REQUEST_GetPriceFactors = ('GET', '/api/ProductPrices/PriceFactors')
+def _prepare_GetPriceFactors(*, criteria) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = criteria.model_dump_json(exclude_unset=True) if criteria is not None else None
+    return params or None, data
+
+_REQUEST_CalculatePrices = ('PATCH', '/api/ProductPrices/CalculatePrices')
+def _prepare_CalculatePrices(*, criteria) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = criteria.model_dump_json(exclude_unset=True) if criteria is not None else None
+    return params or None, data
+
+_REQUEST_OrderPrices = ('PATCH', '/api/ProductPrices/OrderPrices')
+def _prepare_OrderPrices(*, criteria) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = criteria.model_dump_json(exclude_unset=True) if criteria is not None else None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Products/Interfaces/IProductPricesController/_ops.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import IndividualDiscount
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.PriceCalculations import PriceCalculationCriteria
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.PriceCalculations import PriceCalculationResult
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import PriceFactor
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import PriceFactorCriteria
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.PriceCalculations import PriceOrderCriteria
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.PriceCalculations import PriceOrderResult
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import ProductPriceListElement
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import ProductPricesEdit
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import ProductSalePriceBase
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import QuantitativeDiscount
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels.Prices import QuantitativeDiscountListElement
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/ProductPrices/Update', parser=_parse_Update)
+
+def _parse_Recalculate(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Recalculate = OperationSpec(method='PATCH', path='/api/ProductPrices/Recalculate', parser=_parse_Recalculate)
+
+_ADAPTER_GetSalePricesByProduct = TypeAdapter(List[ProductSalePriceBase])
+
+def _parse_GetSalePricesByProduct(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductSalePriceBase]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetSalePricesByProduct)
+OP_GetSalePricesByProduct = OperationSpec(method='GET', path='/api/ProductPrices/SalePrices', parser=_parse_GetSalePricesByProduct)
+
+_ADAPTER_GetSalePricesByProductKind = TypeAdapter(List[ProductPriceListElement])
+
+def _parse_GetSalePricesByProductKind(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductPriceListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetSalePricesByProductKind)
+OP_GetSalePricesByProductKind = OperationSpec(method='GET', path='/api/ProductPrices/SalePrices', parser=_parse_GetSalePricesByProductKind)
+
+_ADAPTER_GetQuantitativeDiscountsByProduct = TypeAdapter(List[QuantitativeDiscount])
+
+def _parse_GetQuantitativeDiscountsByProduct(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[QuantitativeDiscount]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetQuantitativeDiscountsByProduct)
+OP_GetQuantitativeDiscountsByProduct = OperationSpec(method='GET', path='/api/ProductPrices/QuantitativeDiscounts', parser=_parse_GetQuantitativeDiscountsByProduct)
+
+_ADAPTER_GetQuantitativeDiscountsByProductKind = TypeAdapter(List[QuantitativeDiscountListElement])
+
+def _parse_GetQuantitativeDiscountsByProductKind(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[QuantitativeDiscountListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetQuantitativeDiscountsByProductKind)
+OP_GetQuantitativeDiscountsByProductKind = OperationSpec(method='GET', path='/api/ProductPrices/QuantitativeDiscounts', parser=_parse_GetQuantitativeDiscountsByProductKind)
+
+_ADAPTER_GetIndividualDiscountsByContractor = TypeAdapter(List[IndividualDiscount])
+
+def _parse_GetIndividualDiscountsByContractor(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[IndividualDiscount]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetIndividualDiscountsByContractor)
+OP_GetIndividualDiscountsByContractor = OperationSpec(method='GET', path='/api/ProductPrices/IndividualDiscounts', parser=_parse_GetIndividualDiscountsByContractor)
+
+_ADAPTER_GetIndividualDiscountsByContractorKind = TypeAdapter(List[IndividualDiscount])
+
+def _parse_GetIndividualDiscountsByContractorKind(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[IndividualDiscount]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetIndividualDiscountsByContractorKind)
+OP_GetIndividualDiscountsByContractorKind = OperationSpec(method='GET', path='/api/ProductPrices/IndividualDiscounts', parser=_parse_GetIndividualDiscountsByContractorKind)
+
+_ADAPTER_GetPriceFactors = TypeAdapter(List[PriceFactor])
+
+def _parse_GetPriceFactors(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[PriceFactor]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetPriceFactors)
+OP_GetPriceFactors = OperationSpec(method='GET', path='/api/ProductPrices/PriceFactors', parser=_parse_GetPriceFactors)
+
+_ADAPTER_CalculatePrices = TypeAdapter(PriceCalculationResult)
+
+def _parse_CalculatePrices(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[PriceCalculationResult]:
+    return parse_with_adapter(envelope, _ADAPTER_CalculatePrices)
+OP_CalculatePrices = OperationSpec(method='PATCH', path='/api/ProductPrices/CalculatePrices', parser=_parse_CalculatePrices)
+
+_ADAPTER_OrderPrices = TypeAdapter(PriceOrderResult)
+
+def _parse_OrderPrices(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[PriceOrderResult]:
+    return parse_with_adapter(envelope, _ADAPTER_OrderPrices)
+OP_OrderPrices = OperationSpec(method='PATCH', path='/api/ProductPrices/OrderPrices', parser=_parse_OrderPrices)