SymfWebAPI 1.26.10.1__py3-none-any.whl

SymfWebAPI/WebAPI/Interface/HMF/__init__.py

@@ -0,0 +1,21 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("Develogic",)
+
+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 Develogic as _Develogic

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

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import warnings
+
+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.errors import SessionManagementBypassWarning
+from ._common import (
+    _prepare_OpenNewSession,
+)
+from ._ops import (
+    OP_OpenNewSession,
+)
+
+@overload
+def OpenNewSession(api: SyncInvokerProtocol, deviceName: str) -> ResponseEnvelope[None]: ...
+@overload
+def OpenNewSession(api: SyncRequestProtocol, deviceName: str) -> ResponseEnvelope[None]: ...
+@overload
+def OpenNewSession(api: AsyncInvokerProtocol, deviceName: str) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def OpenNewSession(api: AsyncRequestProtocol, deviceName: str) -> Awaitable[ResponseEnvelope[None]]: ...
+def OpenNewSession(api: object, deviceName: str) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    warnings.warn(
+        "Manual call to session endpoint bypasses SessionManager; " "prefer api.open()/api.close() unless you intentionally manage sessions manually.",
+        SessionManagementBypassWarning,
+        stacklevel=2,
+    )
+    params, data = _prepare_OpenNewSession(deviceName=deviceName)
+    return invoke_operation(api, OP_OpenNewSession, params=params, data=data)
+
+__all__ = ["OpenNewSession"]

SymfWebAPI/WebAPI/Interface/Interfaces/ISessionController/_common.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_OpenNewSession = ('GET', '/api/Sessions/OpenNewSession')
+def _prepare_OpenNewSession(*, deviceName) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["deviceName"] = deviceName
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Interfaces/ISessionController/_ops.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+
+def _parse_OpenNewSession(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_OpenNewSession = OperationSpec(method='GET', path='/api/Sessions/OpenNewSession', parser=_parse_OpenNewSession)

SymfWebAPI/WebAPI/Interface/Interfaces/__init__.py

@@ -0,0 +1,21 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("ISessionController",)
+
+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 ISessionController as _ISessionController

SymfWebAPI/WebAPI/Interface/InventoryStates/Interfaces/IInventoryStatesController/__init__.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, overload
+from datetime import datetime
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.InventoryStates.ViewModels import InventoryState
+from ._common import (
+    _prepare_GetByProductId,
+    _prepare_GetByProductCode,
+    _prepare_GetByWarehouseId,
+    _prepare_GetByWarehouseCode,
+    _prepare_GetByProductIdAndWarehouseId,
+    _prepare_GetChanges,
+)
+from ._ops import (
+    OP_GetByProductId,
+    OP_GetByProductCode,
+    OP_GetByWarehouseId,
+    OP_GetByWarehouseCode,
+    OP_GetByProductIdAndWarehouseId,
+    OP_GetChanges,
+)
+
+@overload
+def GetByProductId(api: SyncInvokerProtocol, id: int) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetByProductId(api: SyncRequestProtocol, id: int) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetByProductId(api: AsyncInvokerProtocol, id: int) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+@overload
+def GetByProductId(api: AsyncRequestProtocol, id: int) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+def GetByProductId(api: object, id: int) -> ResponseEnvelope[List[InventoryState]] | Awaitable[ResponseEnvelope[List[InventoryState]]]:
+    params, data = _prepare_GetByProductId(id=id)
+    return invoke_operation(api, OP_GetByProductId, params=params, data=data)
+
+@overload
+def GetByProductCode(api: SyncInvokerProtocol, code: str) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetByProductCode(api: SyncRequestProtocol, code: str) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetByProductCode(api: AsyncInvokerProtocol, code: str) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+@overload
+def GetByProductCode(api: AsyncRequestProtocol, code: str) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+def GetByProductCode(api: object, code: str) -> ResponseEnvelope[List[InventoryState]] | Awaitable[ResponseEnvelope[List[InventoryState]]]:
+    params, data = _prepare_GetByProductCode(code=code)
+    return invoke_operation(api, OP_GetByProductCode, params=params, data=data)
+
+@overload
+def GetByWarehouseId(api: SyncInvokerProtocol, id: int) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetByWarehouseId(api: SyncRequestProtocol, id: int) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetByWarehouseId(api: AsyncInvokerProtocol, id: int) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+@overload
+def GetByWarehouseId(api: AsyncRequestProtocol, id: int) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+def GetByWarehouseId(api: object, id: int) -> ResponseEnvelope[List[InventoryState]] | Awaitable[ResponseEnvelope[List[InventoryState]]]:
+    params, data = _prepare_GetByWarehouseId(id=id)
+    return invoke_operation(api, OP_GetByWarehouseId, params=params, data=data)
+
+@overload
+def GetByWarehouseCode(api: SyncInvokerProtocol, code: str) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetByWarehouseCode(api: SyncRequestProtocol, code: str) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetByWarehouseCode(api: AsyncInvokerProtocol, code: str) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+@overload
+def GetByWarehouseCode(api: AsyncRequestProtocol, code: str) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+def GetByWarehouseCode(api: object, code: str) -> ResponseEnvelope[List[InventoryState]] | Awaitable[ResponseEnvelope[List[InventoryState]]]:
+    params, data = _prepare_GetByWarehouseCode(code=code)
+    return invoke_operation(api, OP_GetByWarehouseCode, params=params, data=data)
+
+@overload
+def GetByProductIdAndWarehouseId(api: SyncInvokerProtocol, productId: int, warehouseId: int) -> ResponseEnvelope[InventoryState]: ...
+@overload
+def GetByProductIdAndWarehouseId(api: SyncRequestProtocol, productId: int, warehouseId: int) -> ResponseEnvelope[InventoryState]: ...
+@overload
+def GetByProductIdAndWarehouseId(api: AsyncInvokerProtocol, productId: int, warehouseId: int) -> Awaitable[ResponseEnvelope[InventoryState]]: ...
+@overload
+def GetByProductIdAndWarehouseId(api: AsyncRequestProtocol, productId: int, warehouseId: int) -> Awaitable[ResponseEnvelope[InventoryState]]: ...
+def GetByProductIdAndWarehouseId(api: object, productId: int, warehouseId: int) -> ResponseEnvelope[InventoryState] | Awaitable[ResponseEnvelope[InventoryState]]:
+    params, data = _prepare_GetByProductIdAndWarehouseId(productId=productId, warehouseId=warehouseId)
+    return invoke_operation(api, OP_GetByProductIdAndWarehouseId, params=params, data=data)
+
+@overload
+def GetChanges(api: SyncInvokerProtocol, date: datetime) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetChanges(api: SyncRequestProtocol, date: datetime) -> ResponseEnvelope[List[InventoryState]]: ...
+@overload
+def GetChanges(api: AsyncInvokerProtocol, date: datetime) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+@overload
+def GetChanges(api: AsyncRequestProtocol, date: datetime) -> Awaitable[ResponseEnvelope[List[InventoryState]]]: ...
+def GetChanges(api: object, date: datetime) -> ResponseEnvelope[List[InventoryState]] | Awaitable[ResponseEnvelope[List[InventoryState]]]:
+    params, data = _prepare_GetChanges(date=date)
+    return invoke_operation(api, OP_GetChanges, params=params, data=data)
+
+__all__ = ["GetByProductId", "GetByProductCode", "GetByWarehouseId", "GetByWarehouseCode", "GetByProductIdAndWarehouseId", "GetChanges"]

SymfWebAPI/WebAPI/Interface/InventoryStates/Interfaces/IInventoryStatesController/_common.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_GetByProductId = ('GET', '/api/InventoryStates/ByProduct')
+def _prepare_GetByProductId(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data
+
+_REQUEST_GetByProductCode = ('GET', '/api/InventoryStates/ByProduct')
+def _prepare_GetByProductCode(*, code) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["code"] = code
+    data = None
+    return params or None, data
+
+_REQUEST_GetByWarehouseId = ('GET', '/api/InventoryStates/ByWarehouse')
+def _prepare_GetByWarehouseId(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data
+
+_REQUEST_GetByWarehouseCode = ('GET', '/api/InventoryStates/ByWarehouse')
+def _prepare_GetByWarehouseCode(*, code) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["code"] = code
+    data = None
+    return params or None, data
+
+_REQUEST_GetByProductIdAndWarehouseId = ('GET', '/api/InventoryStates/ByProductAndWarehouse')
+def _prepare_GetByProductIdAndWarehouseId(*, productId, warehouseId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["productId"] = productId
+    params["warehouseId"] = warehouseId
+    data = None
+    return params or None, data
+
+_REQUEST_GetChanges = ('GET', '/api/InventoryStates/Changes')
+def _prepare_GetChanges(*, date) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["date"] = date
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/InventoryStates/Interfaces/IInventoryStatesController/_ops.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import List
+from datetime import datetime
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.InventoryStates.ViewModels import InventoryState
+
+_ADAPTER_GetByProductId = TypeAdapter(List[InventoryState])
+
+def _parse_GetByProductId(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[InventoryState]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByProductId)
+OP_GetByProductId = OperationSpec(method='GET', path='/api/InventoryStates/ByProduct', parser=_parse_GetByProductId)
+
+_ADAPTER_GetByProductCode = TypeAdapter(List[InventoryState])
+
+def _parse_GetByProductCode(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[InventoryState]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByProductCode)
+OP_GetByProductCode = OperationSpec(method='GET', path='/api/InventoryStates/ByProduct', parser=_parse_GetByProductCode)
+
+_ADAPTER_GetByWarehouseId = TypeAdapter(List[InventoryState])
+
+def _parse_GetByWarehouseId(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[InventoryState]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByWarehouseId)
+OP_GetByWarehouseId = OperationSpec(method='GET', path='/api/InventoryStates/ByWarehouse', parser=_parse_GetByWarehouseId)
+
+_ADAPTER_GetByWarehouseCode = TypeAdapter(List[InventoryState])
+
+def _parse_GetByWarehouseCode(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[InventoryState]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByWarehouseCode)
+OP_GetByWarehouseCode = OperationSpec(method='GET', path='/api/InventoryStates/ByWarehouse', parser=_parse_GetByWarehouseCode)
+
+_ADAPTER_GetByProductIdAndWarehouseId = TypeAdapter(InventoryState)
+
+def _parse_GetByProductIdAndWarehouseId(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[InventoryState]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByProductIdAndWarehouseId)
+OP_GetByProductIdAndWarehouseId = OperationSpec(method='GET', path='/api/InventoryStates/ByProductAndWarehouse', parser=_parse_GetByProductIdAndWarehouseId)
+
+_ADAPTER_GetChanges = TypeAdapter(List[InventoryState])
+
+def _parse_GetChanges(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[InventoryState]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetChanges)
+OP_GetChanges = OperationSpec(method='GET', path='/api/InventoryStates/Changes', parser=_parse_GetChanges)

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

@@ -0,0 +1,21 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("IInventoryStatesController",)
+
+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 IInventoryStatesController as _IInventoryStatesController

SymfWebAPI/WebAPI/Interface/InventoryStates/ViewModels/__init__.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from decimal import Decimal
+
+class InventoryState(BaseModel):
+    ProductId: int
+    WarehouseId: int
+    AmountInStore: Decimal
+    AmountToSale: Decimal

SymfWebAPI/WebAPI/Interface/InventoryStates/__init__.py

@@ -0,0 +1,22 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("Interfaces", "ViewModels",)
+
+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 Interfaces as _Interfaces
+    from . import ViewModels as _ViewModels

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssContractorsController/__init__.py

@@ -0,0 +1,55 @@
+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.FKF.Contractors.ViewModels.V2026_1 import Contractor
+from ._common import (
+    _prepare_Get,
+    _prepare_AddNew,
+    _prepare_Update,
+)
+from ._ops import (
+    OP_Get,
+    OP_AddNew,
+    OP_Update,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, id: int) -> ResponseEnvelope[Contractor]: ...
+@overload
+def Get(api: SyncRequestProtocol, id: int) -> ResponseEnvelope[Contractor]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, id: int) -> Awaitable[ResponseEnvelope[Contractor]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, id: int) -> Awaitable[ResponseEnvelope[Contractor]]: ...
+def Get(api: object, id: int) -> ResponseEnvelope[Contractor] | Awaitable[ResponseEnvelope[Contractor]]:
+    params, data = _prepare_Get(id=id)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, syncFk: bool, contractor: "Contractor") -> ResponseEnvelope[Contractor]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, syncFk: bool, contractor: "Contractor") -> ResponseEnvelope[Contractor]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, syncFk: bool, contractor: "Contractor") -> Awaitable[ResponseEnvelope[Contractor]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, syncFk: bool, contractor: "Contractor") -> Awaitable[ResponseEnvelope[Contractor]]: ...
+def AddNew(api: object, syncFk: bool, contractor: "Contractor") -> ResponseEnvelope[Contractor] | Awaitable[ResponseEnvelope[Contractor]]:
+    params, data = _prepare_AddNew(syncFk=syncFk, contractor=contractor)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def Update(api: SyncInvokerProtocol, syncFk: bool, contractor: "Contractor") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, syncFk: bool, contractor: "Contractor") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, syncFk: bool, contractor: "Contractor") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, syncFk: bool, contractor: "Contractor") -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, syncFk: bool, contractor: "Contractor") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(syncFk=syncFk, contractor=contractor)
+    return invoke_operation(api, OP_Update, params=params, data=data)
+
+__all__ = ["Get", "AddNew", "Update"]

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssContractorsController/_common.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/OssContractors')
+def _prepare_Get(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data
+
+_REQUEST_AddNew = ('POST', '/api/OssContractors/Create')
+def _prepare_AddNew(*, syncFk, contractor) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["syncFk"] = syncFk
+    data = contractor.model_dump_json(exclude_unset=True) if contractor is not None else None
+    return params or None, data
+
+_REQUEST_Update = ('PUT', '/api/OssContractors/Update')
+def _prepare_Update(*, syncFk, contractor) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["syncFk"] = syncFk
+    data = contractor.model_dump_json(exclude_unset=True) if contractor is not None else None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssContractorsController/_ops.py

@@ -0,0 +1,22 @@
+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.FKF.Contractors.ViewModels.V2026_1 import Contractor
+
+_ADAPTER_Get = TypeAdapter(Contractor)
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Contractor]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/OssContractors', parser=_parse_Get)
+
+_ADAPTER_AddNew = TypeAdapter(Contractor)
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Contractor]:
+    return parse_with_adapter(envelope, _ADAPTER_AddNew)
+OP_AddNew = OperationSpec(method='POST', path='/api/OssContractors/Create', parser=_parse_AddNew)
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/OssContractors/Update', parser=_parse_Update)

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssOrderController/__init__.py

@@ -0,0 +1,58 @@
+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.Orders.ViewModels import Order
+from SymfWebAPI.WebAPI.Interface.Orders.ViewModels import OrderFV
+from SymfWebAPI.WebAPI.Interface.Orders.ViewModels import OrderWZ
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels.Orders import OssOrder
+from ._common import (
+    _prepare_AddNew,
+    _prepare_IssueFV,
+    _prepare_IssueWZ,
+)
+from ._ops import (
+    OP_AddNew,
+    OP_IssueFV,
+    OP_IssueWZ,
+)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, issue: bool, order: "OssOrder") -> ResponseEnvelope[Order]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, issue: bool, order: "OssOrder") -> ResponseEnvelope[Order]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, issue: bool, order: "OssOrder") -> Awaitable[ResponseEnvelope[Order]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, issue: bool, order: "OssOrder") -> Awaitable[ResponseEnvelope[Order]]: ...
+def AddNew(api: object, issue: bool, order: "OssOrder") -> ResponseEnvelope[Order] | Awaitable[ResponseEnvelope[Order]]:
+    params, data = _prepare_AddNew(issue=issue, order=order)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def IssueFV(api: SyncInvokerProtocol, orderId: int) -> ResponseEnvelope[List[OrderFV]]: ...
+@overload
+def IssueFV(api: SyncRequestProtocol, orderId: int) -> ResponseEnvelope[List[OrderFV]]: ...
+@overload
+def IssueFV(api: AsyncInvokerProtocol, orderId: int) -> Awaitable[ResponseEnvelope[List[OrderFV]]]: ...
+@overload
+def IssueFV(api: AsyncRequestProtocol, orderId: int) -> Awaitable[ResponseEnvelope[List[OrderFV]]]: ...
+def IssueFV(api: object, orderId: int) -> ResponseEnvelope[List[OrderFV]] | Awaitable[ResponseEnvelope[List[OrderFV]]]:
+    params, data = _prepare_IssueFV(orderId=orderId)
+    return invoke_operation(api, OP_IssueFV, params=params, data=data)
+
+@overload
+def IssueWZ(api: SyncInvokerProtocol, orderId: int, inBuffer: bool) -> ResponseEnvelope[List[OrderWZ]]: ...
+@overload
+def IssueWZ(api: SyncRequestProtocol, orderId: int, inBuffer: bool) -> ResponseEnvelope[List[OrderWZ]]: ...
+@overload
+def IssueWZ(api: AsyncInvokerProtocol, orderId: int, inBuffer: bool) -> Awaitable[ResponseEnvelope[List[OrderWZ]]]: ...
+@overload
+def IssueWZ(api: AsyncRequestProtocol, orderId: int, inBuffer: bool) -> Awaitable[ResponseEnvelope[List[OrderWZ]]]: ...
+def IssueWZ(api: object, orderId: int, inBuffer: bool) -> ResponseEnvelope[List[OrderWZ]] | Awaitable[ResponseEnvelope[List[OrderWZ]]]:
+    params, data = _prepare_IssueWZ(orderId=orderId, inBuffer=inBuffer)
+    return invoke_operation(api, OP_IssueWZ, params=params, data=data)
+
+__all__ = ["AddNew", "IssueFV", "IssueWZ"]

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssOrderController/_common.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_AddNew = ('POST', '/api/OssOrder/New')
+def _prepare_AddNew(*, issue, order) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["issue"] = issue
+    data = order.model_dump_json(exclude_unset=True) if order is not None else None
+    return params or None, data
+
+_REQUEST_IssueFV = ('PUT', '/api/OssOrder/FV')
+def _prepare_IssueFV(*, orderId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["orderId"] = orderId
+    data = None
+    return params or None, data
+
+_REQUEST_IssueWZ = ('PUT', '/api/OssOrder/WZ')
+def _prepare_IssueWZ(*, orderId, inBuffer) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["orderId"] = orderId
+    params["inBuffer"] = inBuffer
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssOrderController/_ops.py

@@ -0,0 +1,28 @@
+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.Orders.ViewModels import Order
+from SymfWebAPI.WebAPI.Interface.Orders.ViewModels import OrderFV
+from SymfWebAPI.WebAPI.Interface.Orders.ViewModels import OrderWZ
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels.Orders import OssOrder
+
+_ADAPTER_AddNew = TypeAdapter(Order)
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Order]:
+    return parse_with_adapter(envelope, _ADAPTER_AddNew)
+OP_AddNew = OperationSpec(method='POST', path='/api/OssOrder/New', parser=_parse_AddNew)
+
+_ADAPTER_IssueFV = TypeAdapter(List[OrderFV])
+
+def _parse_IssueFV(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[OrderFV]]:
+    return parse_with_adapter(envelope, _ADAPTER_IssueFV)
+OP_IssueFV = OperationSpec(method='PUT', path='/api/OssOrder/FV', parser=_parse_IssueFV)
+
+_ADAPTER_IssueWZ = TypeAdapter(List[OrderWZ])
+
+def _parse_IssueWZ(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[OrderWZ]]:
+    return parse_with_adapter(envelope, _ADAPTER_IssueWZ)
+OP_IssueWZ = OperationSpec(method='PUT', path='/api/OssOrder/WZ', parser=_parse_IssueWZ)

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssProductController/__init__.py

@@ -0,0 +1,55 @@
+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.OSS.ViewModels import CountryProductList
+from ._common import (
+    _prepare_GetByCountry,
+    _prepare_GetByErpProduct,
+    _prepare_GetByShopProduct,
+)
+from ._ops import (
+    OP_GetByCountry,
+    OP_GetByErpProduct,
+    OP_GetByShopProduct,
+)
+
+@overload
+def GetByCountry(api: SyncInvokerProtocol, countryId: int) -> ResponseEnvelope[CountryProductList]: ...
+@overload
+def GetByCountry(api: SyncRequestProtocol, countryId: int) -> ResponseEnvelope[CountryProductList]: ...
+@overload
+def GetByCountry(api: AsyncInvokerProtocol, countryId: int) -> Awaitable[ResponseEnvelope[CountryProductList]]: ...
+@overload
+def GetByCountry(api: AsyncRequestProtocol, countryId: int) -> Awaitable[ResponseEnvelope[CountryProductList]]: ...
+def GetByCountry(api: object, countryId: int) -> ResponseEnvelope[CountryProductList] | Awaitable[ResponseEnvelope[CountryProductList]]:
+    params, data = _prepare_GetByCountry(countryId=countryId)
+    return invoke_operation(api, OP_GetByCountry, params=params, data=data)
+
+@overload
+def GetByErpProduct(api: SyncInvokerProtocol, erpProductId: int) -> ResponseEnvelope[CountryProductList]: ...
+@overload
+def GetByErpProduct(api: SyncRequestProtocol, erpProductId: int) -> ResponseEnvelope[CountryProductList]: ...
+@overload
+def GetByErpProduct(api: AsyncInvokerProtocol, erpProductId: int) -> Awaitable[ResponseEnvelope[CountryProductList]]: ...
+@overload
+def GetByErpProduct(api: AsyncRequestProtocol, erpProductId: int) -> Awaitable[ResponseEnvelope[CountryProductList]]: ...
+def GetByErpProduct(api: object, erpProductId: int) -> ResponseEnvelope[CountryProductList] | Awaitable[ResponseEnvelope[CountryProductList]]:
+    params, data = _prepare_GetByErpProduct(erpProductId=erpProductId)
+    return invoke_operation(api, OP_GetByErpProduct, params=params, data=data)
+
+@overload
+def GetByShopProduct(api: SyncInvokerProtocol, shopProductId: str) -> ResponseEnvelope[CountryProductList]: ...
+@overload
+def GetByShopProduct(api: SyncRequestProtocol, shopProductId: str) -> ResponseEnvelope[CountryProductList]: ...
+@overload
+def GetByShopProduct(api: AsyncInvokerProtocol, shopProductId: str) -> Awaitable[ResponseEnvelope[CountryProductList]]: ...
+@overload
+def GetByShopProduct(api: AsyncRequestProtocol, shopProductId: str) -> Awaitable[ResponseEnvelope[CountryProductList]]: ...
+def GetByShopProduct(api: object, shopProductId: str) -> ResponseEnvelope[CountryProductList] | Awaitable[ResponseEnvelope[CountryProductList]]:
+    params, data = _prepare_GetByShopProduct(shopProductId=shopProductId)
+    return invoke_operation(api, OP_GetByShopProduct, params=params, data=data)
+
+__all__ = ["GetByCountry", "GetByErpProduct", "GetByShopProduct"]

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssProductController/_common.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_GetByCountry = ('GET', '/api/OssProduct')
+def _prepare_GetByCountry(*, countryId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["countryId"] = countryId
+    data = None
+    return params or None, data
+
+_REQUEST_GetByErpProduct = ('GET', '/api/OssProduct')
+def _prepare_GetByErpProduct(*, erpProductId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["erpProductId"] = erpProductId
+    data = None
+    return params or None, data
+
+_REQUEST_GetByShopProduct = ('GET', '/api/OssProduct')
+def _prepare_GetByShopProduct(*, shopProductId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["shopProductId"] = shopProductId
+    data = None
+    return params or None, data