SymfWebAPI 1.26.10.1__py3-none-any.whl

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

@@ -0,0 +1,247 @@
+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.Common.ViewModels import IncrementalSyncListElement
+from SymfWebAPI.WebAPI.Interface.ViewModels import Page
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import Product
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductBarcodes
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductCriteriaFilter
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductFilterCriteria
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductListElement
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductListElementWithDimensions
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductListElementWithSalePrices
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductLogisticField
+from SymfWebAPI.WebAPI.Interface.Enums import enumOrderByType
+from ._common import (
+    _prepare_Get,
+    _prepare_Filter,
+    _prepare_FilterWithSalePrices,
+    _prepare_FilterWithDimensions,
+    _prepare_AddNew,
+    _prepare_Update,
+    _prepare_IncrementalSync,
+    _prepare_GetBarcodes,
+    _prepare_UpdateBarcodes,
+    _prepare_FilterSql,
+    _prepare_GetPagedDocument,
+    _prepare_GetPageWithSalePrices,
+    _prepare_GetPageWithDimensions,
+    _prepare_FilterSqlWthSalePrices,
+    _prepare_FilterSqlWthDimensions,
+    _prepare_GetLogisticFields,
+)
+from ._ops import (
+    OP_Get,
+    OP_Filter,
+    OP_FilterWithSalePrices,
+    OP_FilterWithDimensions,
+    OP_AddNew,
+    OP_Update,
+    OP_IncrementalSync,
+    OP_GetBarcodes,
+    OP_UpdateBarcodes,
+    OP_FilterSql,
+    OP_GetPagedDocument,
+    OP_GetPageWithSalePrices,
+    OP_GetPageWithDimensions,
+    OP_FilterSqlWthSalePrices,
+    OP_FilterSqlWthDimensions,
+    OP_GetLogisticFields,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, salePrices: bool) -> ResponseEnvelope[List[ProductListElement]]: ...
+@overload
+def Get(api: SyncRequestProtocol, salePrices: bool) -> ResponseEnvelope[List[ProductListElement]]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, salePrices: bool) -> Awaitable[ResponseEnvelope[List[ProductListElement]]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, salePrices: bool) -> Awaitable[ResponseEnvelope[List[ProductListElement]]]: ...
+def Get(api: object, salePrices: bool) -> ResponseEnvelope[List[ProductListElement]] | Awaitable[ResponseEnvelope[List[ProductListElement]]]:
+    params, data = _prepare_Get(salePrices=salePrices)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+@overload
+def Filter(api: SyncInvokerProtocol, salePrices: bool, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElement]]: ...
+@overload
+def Filter(api: SyncRequestProtocol, salePrices: bool, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElement]]: ...
+@overload
+def Filter(api: AsyncInvokerProtocol, salePrices: bool, criteria: "ProductFilterCriteria") -> Awaitable[ResponseEnvelope[List[ProductListElement]]]: ...
+@overload
+def Filter(api: AsyncRequestProtocol, salePrices: bool, criteria: "ProductFilterCriteria") -> Awaitable[ResponseEnvelope[List[ProductListElement]]]: ...
+def Filter(api: object, salePrices: bool, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElement]] | Awaitable[ResponseEnvelope[List[ProductListElement]]]:
+    params, data = _prepare_Filter(salePrices=salePrices, criteria=criteria)
+    return invoke_operation(api, OP_Filter, params=params, data=data)
+
+@overload
+def FilterWithSalePrices(api: SyncInvokerProtocol, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElementWithSalePrices]]: ...
+@overload
+def FilterWithSalePrices(api: SyncRequestProtocol, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElementWithSalePrices]]: ...
+@overload
+def FilterWithSalePrices(api: AsyncInvokerProtocol, criteria: "ProductFilterCriteria") -> Awaitable[ResponseEnvelope[List[ProductListElementWithSalePrices]]]: ...
+@overload
+def FilterWithSalePrices(api: AsyncRequestProtocol, criteria: "ProductFilterCriteria") -> Awaitable[ResponseEnvelope[List[ProductListElementWithSalePrices]]]: ...
+def FilterWithSalePrices(api: object, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElementWithSalePrices]] | Awaitable[ResponseEnvelope[List[ProductListElementWithSalePrices]]]:
+    params, data = _prepare_FilterWithSalePrices(criteria=criteria)
+    return invoke_operation(api, OP_FilterWithSalePrices, params=params, data=data)
+
+@overload
+def FilterWithDimensions(api: SyncInvokerProtocol, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElementWithDimensions]]: ...
+@overload
+def FilterWithDimensions(api: SyncRequestProtocol, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElementWithDimensions]]: ...
+@overload
+def FilterWithDimensions(api: AsyncInvokerProtocol, criteria: "ProductFilterCriteria") -> Awaitable[ResponseEnvelope[List[ProductListElementWithDimensions]]]: ...
+@overload
+def FilterWithDimensions(api: AsyncRequestProtocol, criteria: "ProductFilterCriteria") -> Awaitable[ResponseEnvelope[List[ProductListElementWithDimensions]]]: ...
+def FilterWithDimensions(api: object, criteria: "ProductFilterCriteria") -> ResponseEnvelope[List[ProductListElementWithDimensions]] | Awaitable[ResponseEnvelope[List[ProductListElementWithDimensions]]]:
+    params, data = _prepare_FilterWithDimensions(criteria=criteria)
+    return invoke_operation(api, OP_FilterWithDimensions, params=params, data=data)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, product: "Product") -> ResponseEnvelope[Product]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, product: "Product") -> ResponseEnvelope[Product]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, product: "Product") -> Awaitable[ResponseEnvelope[Product]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, product: "Product") -> Awaitable[ResponseEnvelope[Product]]: ...
+def AddNew(api: object, product: "Product") -> ResponseEnvelope[Product] | Awaitable[ResponseEnvelope[Product]]:
+    params, data = _prepare_AddNew(product=product)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def Update(api: SyncInvokerProtocol, product: "Product") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, product: "Product") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, product: "Product") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, product: "Product") -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, product: "Product") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(product=product)
+    return invoke_operation(api, OP_Update, params=params, data=data)
+
+@overload
+def IncrementalSync(api: SyncInvokerProtocol) -> ResponseEnvelope[List[IncrementalSyncListElement]]: ...
+@overload
+def IncrementalSync(api: SyncRequestProtocol) -> ResponseEnvelope[List[IncrementalSyncListElement]]: ...
+@overload
+def IncrementalSync(api: AsyncInvokerProtocol) -> Awaitable[ResponseEnvelope[List[IncrementalSyncListElement]]]: ...
+@overload
+def IncrementalSync(api: AsyncRequestProtocol) -> Awaitable[ResponseEnvelope[List[IncrementalSyncListElement]]]: ...
+def IncrementalSync(api: object) -> ResponseEnvelope[List[IncrementalSyncListElement]] | Awaitable[ResponseEnvelope[List[IncrementalSyncListElement]]]:
+    params, data = _prepare_IncrementalSync()
+    return invoke_operation(api, OP_IncrementalSync, params=params, data=data)
+
+@overload
+def GetBarcodes(api: SyncInvokerProtocol, productCode: str) -> ResponseEnvelope[ProductBarcodes]: ...
+@overload
+def GetBarcodes(api: SyncRequestProtocol, productCode: str) -> ResponseEnvelope[ProductBarcodes]: ...
+@overload
+def GetBarcodes(api: AsyncInvokerProtocol, productCode: str) -> Awaitable[ResponseEnvelope[ProductBarcodes]]: ...
+@overload
+def GetBarcodes(api: AsyncRequestProtocol, productCode: str) -> Awaitable[ResponseEnvelope[ProductBarcodes]]: ...
+def GetBarcodes(api: object, productCode: str) -> ResponseEnvelope[ProductBarcodes] | Awaitable[ResponseEnvelope[ProductBarcodes]]:
+    params, data = _prepare_GetBarcodes(productCode=productCode)
+    return invoke_operation(api, OP_GetBarcodes, params=params, data=data)
+
+@overload
+def UpdateBarcodes(api: SyncInvokerProtocol, productCode: str) -> ResponseEnvelope[None]: ...
+@overload
+def UpdateBarcodes(api: SyncRequestProtocol, productCode: str) -> ResponseEnvelope[None]: ...
+@overload
+def UpdateBarcodes(api: AsyncInvokerProtocol, productCode: str) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def UpdateBarcodes(api: AsyncRequestProtocol, productCode: str) -> Awaitable[ResponseEnvelope[None]]: ...
+def UpdateBarcodes(api: object, productCode: str) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_UpdateBarcodes(productCode=productCode)
+    return invoke_operation(api, OP_UpdateBarcodes, params=params, data=data)
+
+@overload
+def FilterSql(api: SyncInvokerProtocol, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElement]]: ...
+@overload
+def FilterSql(api: SyncRequestProtocol, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElement]]: ...
+@overload
+def FilterSql(api: AsyncInvokerProtocol, criteriaFilter: "ProductCriteriaFilter") -> Awaitable[ResponseEnvelope[List[ProductListElement]]]: ...
+@overload
+def FilterSql(api: AsyncRequestProtocol, criteriaFilter: "ProductCriteriaFilter") -> Awaitable[ResponseEnvelope[List[ProductListElement]]]: ...
+def FilterSql(api: object, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElement]] | Awaitable[ResponseEnvelope[List[ProductListElement]]]:
+    params, data = _prepare_FilterSql(criteriaFilter=criteriaFilter)
+    return invoke_operation(api, OP_FilterSql, params=params, data=data)
+
+@overload
+def GetPagedDocument(api: SyncInvokerProtocol, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page]: ...
+@overload
+def GetPagedDocument(api: SyncRequestProtocol, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page]: ...
+@overload
+def GetPagedDocument(api: AsyncInvokerProtocol, page: int, size: int, orderBy: "enumOrderByType") -> Awaitable[ResponseEnvelope[Page]]: ...
+@overload
+def GetPagedDocument(api: AsyncRequestProtocol, page: int, size: int, orderBy: "enumOrderByType") -> Awaitable[ResponseEnvelope[Page]]: ...
+def GetPagedDocument(api: object, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page] | Awaitable[ResponseEnvelope[Page]]:
+    params, data = _prepare_GetPagedDocument(page=page, size=size, orderBy=orderBy)
+    return invoke_operation(api, OP_GetPagedDocument, params=params, data=data)
+
+@overload
+def GetPageWithSalePrices(api: SyncInvokerProtocol, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page]: ...
+@overload
+def GetPageWithSalePrices(api: SyncRequestProtocol, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page]: ...
+@overload
+def GetPageWithSalePrices(api: AsyncInvokerProtocol, page: int, size: int, orderBy: "enumOrderByType") -> Awaitable[ResponseEnvelope[Page]]: ...
+@overload
+def GetPageWithSalePrices(api: AsyncRequestProtocol, page: int, size: int, orderBy: "enumOrderByType") -> Awaitable[ResponseEnvelope[Page]]: ...
+def GetPageWithSalePrices(api: object, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page] | Awaitable[ResponseEnvelope[Page]]:
+    params, data = _prepare_GetPageWithSalePrices(page=page, size=size, orderBy=orderBy)
+    return invoke_operation(api, OP_GetPageWithSalePrices, params=params, data=data)
+
+@overload
+def GetPageWithDimensions(api: SyncInvokerProtocol, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page]: ...
+@overload
+def GetPageWithDimensions(api: SyncRequestProtocol, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page]: ...
+@overload
+def GetPageWithDimensions(api: AsyncInvokerProtocol, page: int, size: int, orderBy: "enumOrderByType") -> Awaitable[ResponseEnvelope[Page]]: ...
+@overload
+def GetPageWithDimensions(api: AsyncRequestProtocol, page: int, size: int, orderBy: "enumOrderByType") -> Awaitable[ResponseEnvelope[Page]]: ...
+def GetPageWithDimensions(api: object, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page] | Awaitable[ResponseEnvelope[Page]]:
+    params, data = _prepare_GetPageWithDimensions(page=page, size=size, orderBy=orderBy)
+    return invoke_operation(api, OP_GetPageWithDimensions, params=params, data=data)
+
+@overload
+def FilterSqlWthSalePrices(api: SyncInvokerProtocol, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElementWithSalePrices]]: ...
+@overload
+def FilterSqlWthSalePrices(api: SyncRequestProtocol, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElementWithSalePrices]]: ...
+@overload
+def FilterSqlWthSalePrices(api: AsyncInvokerProtocol, criteriaFilter: "ProductCriteriaFilter") -> Awaitable[ResponseEnvelope[List[ProductListElementWithSalePrices]]]: ...
+@overload
+def FilterSqlWthSalePrices(api: AsyncRequestProtocol, criteriaFilter: "ProductCriteriaFilter") -> Awaitable[ResponseEnvelope[List[ProductListElementWithSalePrices]]]: ...
+def FilterSqlWthSalePrices(api: object, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElementWithSalePrices]] | Awaitable[ResponseEnvelope[List[ProductListElementWithSalePrices]]]:
+    params, data = _prepare_FilterSqlWthSalePrices(criteriaFilter=criteriaFilter)
+    return invoke_operation(api, OP_FilterSqlWthSalePrices, params=params, data=data)
+
+@overload
+def FilterSqlWthDimensions(api: SyncInvokerProtocol, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElementWithDimensions]]: ...
+@overload
+def FilterSqlWthDimensions(api: SyncRequestProtocol, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElementWithDimensions]]: ...
+@overload
+def FilterSqlWthDimensions(api: AsyncInvokerProtocol, criteriaFilter: "ProductCriteriaFilter") -> Awaitable[ResponseEnvelope[List[ProductListElementWithDimensions]]]: ...
+@overload
+def FilterSqlWthDimensions(api: AsyncRequestProtocol, criteriaFilter: "ProductCriteriaFilter") -> Awaitable[ResponseEnvelope[List[ProductListElementWithDimensions]]]: ...
+def FilterSqlWthDimensions(api: object, criteriaFilter: "ProductCriteriaFilter") -> ResponseEnvelope[List[ProductListElementWithDimensions]] | Awaitable[ResponseEnvelope[List[ProductListElementWithDimensions]]]:
+    params, data = _prepare_FilterSqlWthDimensions(criteriaFilter=criteriaFilter)
+    return invoke_operation(api, OP_FilterSqlWthDimensions, params=params, data=data)
+
+@overload
+def GetLogisticFields(api: SyncInvokerProtocol, productCode: str) -> ResponseEnvelope[List[ProductLogisticField]]: ...
+@overload
+def GetLogisticFields(api: SyncRequestProtocol, productCode: str) -> ResponseEnvelope[List[ProductLogisticField]]: ...
+@overload
+def GetLogisticFields(api: AsyncInvokerProtocol, productCode: str) -> Awaitable[ResponseEnvelope[List[ProductLogisticField]]]: ...
+@overload
+def GetLogisticFields(api: AsyncRequestProtocol, productCode: str) -> Awaitable[ResponseEnvelope[List[ProductLogisticField]]]: ...
+def GetLogisticFields(api: object, productCode: str) -> ResponseEnvelope[List[ProductLogisticField]] | Awaitable[ResponseEnvelope[List[ProductLogisticField]]]:
+    params, data = _prepare_GetLogisticFields(productCode=productCode)
+    return invoke_operation(api, OP_GetLogisticFields, params=params, data=data)
+
+__all__ = ["Get", "Filter", "FilterWithSalePrices", "FilterWithDimensions", "AddNew", "Update", "IncrementalSync", "GetBarcodes", "UpdateBarcodes", "FilterSql", "GetPagedDocument", "GetPageWithSalePrices", "GetPageWithDimensions", "FilterSqlWthSalePrices", "FilterSqlWthDimensions", "GetLogisticFields"]

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

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Any
+
+import json
+
+_REQUEST_Get = ('GET', '/api/Products')
+def _prepare_Get(*, salePrices) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["salePrices"] = salePrices
+    data = None
+    return params or None, data
+
+_REQUEST_Filter = ('PATCH', '/api/Products/Filter')
+def _prepare_Filter(*, salePrices, criteria) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["salePrices"] = salePrices
+    data = criteria.model_dump_json(exclude_unset=True) if criteria is not None else None
+    return params or None, data
+
+_REQUEST_FilterWithSalePrices = ('PATCH', '/api/Products/Filter/WithSalePrices')
+def _prepare_FilterWithSalePrices(*, 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_FilterWithDimensions = ('PATCH', '/api/Products/Filter/WithDimensions')
+def _prepare_FilterWithDimensions(*, 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_AddNew = ('POST', '/api/Products/Create')
+def _prepare_AddNew(*, product) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = product.model_dump_json(exclude_unset=True) if product is not None else None
+    return params or None, data
+
+_REQUEST_Update = ('PUT', '/api/Products/Update')
+def _prepare_Update(*, product) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = product.model_dump_json(exclude_unset=True) if product is not None else None
+    return params or None, data
+
+_REQUEST_IncrementalSync = ('GET', '/api/Products/IncrementalSync')
+def _prepare_IncrementalSync() -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = None
+    return params or None, data
+
+_REQUEST_GetBarcodes = ('GET', '/api/Products/Barcodes')
+def _prepare_GetBarcodes(*, productCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = json.dumps(productCode) if productCode is not None else None
+    return params or None, data
+
+_REQUEST_UpdateBarcodes = ('GET', '/api/Products/UpdateBarcodes')
+def _prepare_UpdateBarcodes(*, productCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productCode"] = productCode
+    data = None
+    return params or None, data
+
+_REQUEST_FilterSql = ('PATCH', '/api/Products/FilterSql')
+def _prepare_FilterSql(*, criteriaFilter) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = criteriaFilter.model_dump_json(exclude_unset=True) if criteriaFilter is not None else None
+    return params or None, data
+
+_REQUEST_GetPagedDocument = ('GET', '/api/Products/Page')
+def _prepare_GetPagedDocument(*, page, size, orderBy) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["page"] = page
+    params["size"] = size
+    params["orderBy"] = orderBy.value
+    data = None
+    return params or None, data
+
+_REQUEST_GetPageWithSalePrices = ('GET', '/api/Products/Page/WithSalePrices')
+def _prepare_GetPageWithSalePrices(*, page, size, orderBy) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["page"] = page
+    params["size"] = size
+    params["orderBy"] = orderBy.value
+    data = None
+    return params or None, data
+
+_REQUEST_GetPageWithDimensions = ('GET', '/api/Products/Page/WithDimensions')
+def _prepare_GetPageWithDimensions(*, page, size, orderBy) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["page"] = page
+    params["size"] = size
+    params["orderBy"] = orderBy.value
+    data = None
+    return params or None, data
+
+_REQUEST_FilterSqlWthSalePrices = ('PATCH', '/api/Products/FilterSql/WithSalePrices')
+def _prepare_FilterSqlWthSalePrices(*, criteriaFilter) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = criteriaFilter.model_dump_json(exclude_unset=True) if criteriaFilter is not None else None
+    return params or None, data
+
+_REQUEST_FilterSqlWthDimensions = ('PATCH', '/api/Products/FilterSql/WithDimensions')
+def _prepare_FilterSqlWthDimensions(*, criteriaFilter) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = criteriaFilter.model_dump_json(exclude_unset=True) if criteriaFilter is not None else None
+    return params or None, data
+
+_REQUEST_GetLogisticFields = ('GET', '/api/Products/LogisticFields')
+def _prepare_GetLogisticFields(*, productCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = json.dumps(productCode) if productCode is not None else None
+    return params or None, data

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

@@ -0,0 +1,109 @@
+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.Common.ViewModels import IncrementalSyncListElement
+from SymfWebAPI.WebAPI.Interface.ViewModels import Page
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import Product
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductBarcodes
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductCriteriaFilter
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductFilterCriteria
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductListElement
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductListElementWithDimensions
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductListElementWithSalePrices
+from SymfWebAPI.WebAPI.Interface.Products.ViewModels import ProductLogisticField
+from SymfWebAPI.WebAPI.Interface.Enums import enumOrderByType
+
+_ADAPTER_Get = TypeAdapter(List[ProductListElement])
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/Products', parser=_parse_Get)
+
+_ADAPTER_Filter = TypeAdapter(List[ProductListElement])
+
+def _parse_Filter(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_Filter)
+OP_Filter = OperationSpec(method='PATCH', path='/api/Products/Filter', parser=_parse_Filter)
+
+_ADAPTER_FilterWithSalePrices = TypeAdapter(List[ProductListElementWithSalePrices])
+
+def _parse_FilterWithSalePrices(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductListElementWithSalePrices]]:
+    return parse_with_adapter(envelope, _ADAPTER_FilterWithSalePrices)
+OP_FilterWithSalePrices = OperationSpec(method='PATCH', path='/api/Products/Filter/WithSalePrices', parser=_parse_FilterWithSalePrices)
+
+_ADAPTER_FilterWithDimensions = TypeAdapter(List[ProductListElementWithDimensions])
+
+def _parse_FilterWithDimensions(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductListElementWithDimensions]]:
+    return parse_with_adapter(envelope, _ADAPTER_FilterWithDimensions)
+OP_FilterWithDimensions = OperationSpec(method='PATCH', path='/api/Products/Filter/WithDimensions', parser=_parse_FilterWithDimensions)
+
+_ADAPTER_AddNew = TypeAdapter(Product)
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Product]:
+    return parse_with_adapter(envelope, _ADAPTER_AddNew)
+OP_AddNew = OperationSpec(method='POST', path='/api/Products/Create', parser=_parse_AddNew)
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/Products/Update', parser=_parse_Update)
+
+_ADAPTER_IncrementalSync = TypeAdapter(List[IncrementalSyncListElement])
+
+def _parse_IncrementalSync(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[IncrementalSyncListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_IncrementalSync)
+OP_IncrementalSync = OperationSpec(method='GET', path='/api/Products/IncrementalSync', parser=_parse_IncrementalSync)
+
+_ADAPTER_GetBarcodes = TypeAdapter(ProductBarcodes)
+
+def _parse_GetBarcodes(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[ProductBarcodes]:
+    return parse_with_adapter(envelope, _ADAPTER_GetBarcodes)
+OP_GetBarcodes = OperationSpec(method='GET', path='/api/Products/Barcodes', parser=_parse_GetBarcodes)
+
+def _parse_UpdateBarcodes(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_UpdateBarcodes = OperationSpec(method='GET', path='/api/Products/UpdateBarcodes', parser=_parse_UpdateBarcodes)
+
+_ADAPTER_FilterSql = TypeAdapter(List[ProductListElement])
+
+def _parse_FilterSql(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_FilterSql)
+OP_FilterSql = OperationSpec(method='PATCH', path='/api/Products/FilterSql', parser=_parse_FilterSql)
+
+_ADAPTER_GetPagedDocument = TypeAdapter(Page)
+
+def _parse_GetPagedDocument(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Page]:
+    return parse_with_adapter(envelope, _ADAPTER_GetPagedDocument)
+OP_GetPagedDocument = OperationSpec(method='GET', path='/api/Products/Page', parser=_parse_GetPagedDocument)
+
+_ADAPTER_GetPageWithSalePrices = TypeAdapter(Page)
+
+def _parse_GetPageWithSalePrices(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Page]:
+    return parse_with_adapter(envelope, _ADAPTER_GetPageWithSalePrices)
+OP_GetPageWithSalePrices = OperationSpec(method='GET', path='/api/Products/Page/WithSalePrices', parser=_parse_GetPageWithSalePrices)
+
+_ADAPTER_GetPageWithDimensions = TypeAdapter(Page)
+
+def _parse_GetPageWithDimensions(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Page]:
+    return parse_with_adapter(envelope, _ADAPTER_GetPageWithDimensions)
+OP_GetPageWithDimensions = OperationSpec(method='GET', path='/api/Products/Page/WithDimensions', parser=_parse_GetPageWithDimensions)
+
+_ADAPTER_FilterSqlWthSalePrices = TypeAdapter(List[ProductListElementWithSalePrices])
+
+def _parse_FilterSqlWthSalePrices(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductListElementWithSalePrices]]:
+    return parse_with_adapter(envelope, _ADAPTER_FilterSqlWthSalePrices)
+OP_FilterSqlWthSalePrices = OperationSpec(method='PATCH', path='/api/Products/FilterSql/WithSalePrices', parser=_parse_FilterSqlWthSalePrices)
+
+_ADAPTER_FilterSqlWthDimensions = TypeAdapter(List[ProductListElementWithDimensions])
+
+def _parse_FilterSqlWthDimensions(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductListElementWithDimensions]]:
+    return parse_with_adapter(envelope, _ADAPTER_FilterSqlWthDimensions)
+OP_FilterSqlWthDimensions = OperationSpec(method='PATCH', path='/api/Products/FilterSql/WithDimensions', parser=_parse_FilterSqlWthDimensions)
+
+_ADAPTER_GetLogisticFields = TypeAdapter(List[ProductLogisticField])
+
+def _parse_GetLogisticFields(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductLogisticField]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetLogisticFields)
+OP_GetLogisticFields = OperationSpec(method='GET', path='/api/Products/LogisticFields', parser=_parse_GetLogisticFields)

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

@@ -0,0 +1,26 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("IPriceListsController", "IProductDimensions2Controller", "IProductDimensionsController", "IProductPhotosController", "IProductPricesController", "IProductsController",)
+
+def __getattr__(name: str):
+    if name in __all__:
+        module = importlib.import_module(f".{name}", __name__)
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+def __dir__():
+    return sorted(set(__all__) | {n for n in globals() if not n.startswith('_')})
+
+if TYPE_CHECKING:
+    from . import IPriceListsController as _IPriceListsController
+    from . import IProductDimensions2Controller as _IProductDimensions2Controller
+    from . import IProductDimensionsController as _IProductDimensionsController
+    from . import IProductPhotosController as _IProductPhotosController
+    from . import IProductPricesController as _IProductPricesController
+    from . import IProductsController as _IProductsController

SymfWebAPI/WebAPI/Interface/Products/ViewModels/PriceCalculations/__init__.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from typing import List, Optional
+from datetime import datetime
+from decimal import Decimal
+from SymfWebAPI.WebAPI.Interface.Enums import enumPriceCalculationMethod, enumSalePriceType
+
+class PriceCalculation(BaseModel):
+    DepartmentId: int
+    ContractorId: int
+    Date: datetime
+    PriceType: "enumSalePriceType"
+    Currency: str
+
+class PriceCalculationCriteria(BaseModel):
+    CalculationMethod: "enumPriceCalculationMethod"
+    Products: List["PriceCalculationProductCriteria"]
+    DepartmentId: int
+    ContractorId: int
+    Date: datetime
+    PriceType: "enumSalePriceType"
+    Currency: str
+
+class PriceCalculationProduct(BaseModel):
+    Id: int
+    Quantity: Decimal
+
+class PriceCalculationProductCriteria(BaseModel):
+    Id: int
+    Quantity: Decimal
+
+class PriceCalculationProductResult(BaseModel):
+    Price: Decimal
+    Id: int
+    Quantity: Decimal
+
+class PriceCalculationResult(BaseModel):
+    Products: List["PriceCalculationProductResult"]
+    DepartmentId: int
+    ContractorId: int
+    Date: datetime
+    PriceType: "enumSalePriceType"
+    Currency: str
+
+class PriceOrder(BaseModel):
+    Department: str
+    Date: datetime
+    SalePriceType: "enumSalePriceType"
+    Currency: str
+
+class PriceOrderContractor(BaseModel):
+    Id: Optional[int]
+    Code: str
+
+class PriceOrderContractorCriteria(BaseModel):
+    Id: Optional[int]
+    Code: str
+
+class PriceOrderCriteria(BaseModel):
+    Contractor: "PriceOrderContractorCriteria"
+    TypeCode: str
+    Series: str
+    Products: List["PriceOrderProductCriteria"]
+    Department: str
+    Date: datetime
+    SalePriceType: "enumSalePriceType"
+    Currency: str
+
+class PriceOrderProduct(BaseModel):
+    Code: str
+    Quantity: Decimal
+
+class PriceOrderProductCriteria(BaseModel):
+    Code: str
+    Quantity: Decimal
+
+class PriceOrderProductResult(BaseModel):
+    Id: int
+    Price: Decimal
+    Code: str
+    Quantity: Decimal
+
+class PriceOrderResult(BaseModel):
+    Contractor: "PriceOrderContractor"
+    Products: List["PriceOrderProductResult"]
+    Department: str
+    Date: datetime
+    SalePriceType: "enumSalePriceType"
+    Currency: str

SymfWebAPI/WebAPI/Interface/Products/ViewModels/PriceLists/__init__.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from typing import List, Optional
+from datetime import datetime
+from decimal import Decimal
+from SymfWebAPI.WebAPI.Interface.Enums import (
+    enumPriceFactorType,
+    enumPriceKind,
+    enumPriceListConnectionType,
+    enumSalePriceType,
+)
+
+class PriceList(BaseModel):
+    Id: int
+    Code: str
+    Description: str
+    Active: bool
+    DateFrom: Optional[datetime]
+    DateTo: Optional[datetime]
+    DepartmentId: Optional[int]
+    IsPriceListHistoryEnabled: bool
+    IsCurrencyPriceList: bool
+    PriceListCurrency: str
+    ForAllContractors: bool
+    Priority: int
+    MinimalPriority: int
+    ConnectionType: "enumPriceListConnectionType"
+    Type: "enumPriceFactorType"
+    SpecificWeekdays: bool
+    AvailableOnMonday: bool
+    AvailableOnTuesday: bool
+    AvailableOnWednesday: bool
+    AvailableOnThursday: bool
+    AvailableOnFriday: bool
+    AvailableOnSaturday: bool
+    AvailableOnSunday: bool
+    Products: List["PriceListSubjectDetails"]
+    ProductKinds: List["PriceListSubjectDetails"]
+    Contractors: List["PriceListSubject"]
+    ContractorKinds: List["PriceListSubject"]
+
+class PriceListDetails(BaseModel):
+    Value: Optional[Decimal]
+    Currency: str
+    PriceType: "enumSalePriceType"
+    PriceKind: "enumPriceKind"
+    Type: "enumPriceFactorType"
+
+class PriceListSubject(BaseModel):
+    Id: int
+    Code: str
+    Name: str
+
+class PriceListSubjectDetails(BaseModel):
+    Prices: List["PriceListDetails"]
+    Id: int
+    Code: str
+    Name: str