bb-integrations-library 3.0.11__py3-none-any.whl

bb_integrations_lib/provider/api/pc_miler/web_services_apis.py

@@ -0,0 +1,131 @@
+from datetime import datetime, UTC, timedelta
+from typing import Dict
+from dateutil.parser import parse
+
+import loguru
+
+from bb_integrations_lib.provider.api.pc_miler.client import PCMilerClient
+from bb_integrations_lib.provider.api.pc_miler.model import TokenData
+
+
+class _RoutingAPI:
+    def __init__(self, client: PCMilerClient):
+        self.client = client
+
+    def _custom_headers(self):
+        return {
+            'Authorization': f'{self.client.api_key}',
+            'Accept': 'application/json',
+            'Content-type': 'application/json'
+        }
+
+    async def get_route_reports(self, url: str, params: Dict):
+        custom_headers = self._custom_headers()
+        return await self.client.get(url, params=params, headers=custom_headers)
+
+    @property
+    def service_name(self):
+        return """ROUTING_API"""
+
+
+
+class RoutingAPI(_RoutingAPI):
+    def __init__(self, client: PCMilerClient):
+        super().__init__(client)
+
+
+class _SingleSearchAPI:
+    def __init__(self, client: PCMilerClient):
+        pass
+
+
+class SingleSearchAPI(_SingleSearchAPI):
+    def __init__(self, client: PCMilerClient):
+        super().__init__(client)
+
+
+class _PlacesAPI:
+    def __init__(self, client: PCMilerClient):
+        self.client = client
+        self.tokendata: TokenData | None = None
+
+    async def _custom_headers(self):
+        if not (self.tokendata and self.tokendata.token and datetime.now(UTC) < parse(self.tokendata.expires)):
+            self.tokendata = await self.client.get_token("https://api.trimblemaps.com/places/v1/authenticate")
+        return {
+            'Authorization': f'Bearer {self.tokendata.token}',
+        }
+
+    @property
+    def service_name(self):
+        return """PLACES_API"""
+
+class PlacesAPI(_PlacesAPI):
+    def __init__(self, client: PCMilerClient):
+        super().__init__(client)
+
+    async def get_place_by_id(self, id: str):
+        custom_headers = await self._custom_headers()
+        result = await self.client.get(
+            url=f"https://api.trimblemaps.com/places/v1/place/{id}/details",
+            headers=custom_headers
+        )
+        return result
+
+    async def get_updated_places(self, last_modified_timestamp: str) -> list[dict] | None:
+        custom_headers = await self._custom_headers()
+        # last_modified_record=None
+        all_results = []
+        retries = 3
+        while True:
+            result = await self.client.get(
+                url=f"https://api.trimblemaps.com/places/v1/place/updatedPlaces",
+                params={
+                    "lastModifiedDate": last_modified_timestamp,
+                    # "lastModifiedRecord": last_modified_record,
+                    "pageSize": 100
+                },
+                headers=custom_headers
+            )
+            if result.status_code != 200:
+                retries -= 1
+                if retries == 0:
+                    return None
+                continue
+            data = result.json()
+            items = data.get("items", [])
+            all_results.extend(items)
+            if len(items) < 100:
+                break
+            # last_modified_record = data.get("lastModifiedRecord", None)
+            new_last_modified_timestamp = data.get("lastModifiedTimestamp", datetime(1970, 1, 1).isoformat())
+            if new_last_modified_timestamp == last_modified_timestamp:
+                # WARNING: This is a workaround for a bug in the Trimble API.
+                # In short, the API only returns 100 datapoints at a time, and if a timestamp has more than 100 datapoints
+                # associated it's not possible to get any datapoints after the 100th; the API ONLY lets me pick by timestamp
+                # and not by a generic page number or anything. Bulk operations seem to trigger this worse than most.
+                # As a workaround I will check if the timestamp we're going to "next" is the same as the current one, and add
+                # 1 millisecond if it is.
+                #
+                # This can skip over an unknown number of events! So far I've only seen problems due to mass deletions,
+                # but if there's a mass-edit functionality it could be an issue there too.
+                new_last_modified_timestamp = datetime.fromisoformat(new_last_modified_timestamp) + timedelta(milliseconds=1)
+                new_last_modified_timestamp = new_last_modified_timestamp.isoformat()
+            last_modified_timestamp = new_last_modified_timestamp
+            loguru.logger.debug(f"Fetching page from date {last_modified_timestamp}")
+        return all_results
+
+    async def create_place(self, place_req: dict, dry_run: bool = False):
+        custom_headers = await self._custom_headers()
+        if dry_run:
+            loguru.logger.debug(f"Dry run: Would create place {place_req}")
+            return
+
+        result = await self.client.post(
+            url=f"https://api.trimblemaps.com/places/v1/place",
+            json=place_req,
+            headers=custom_headers
+        )
+        loguru.logger.debug(result.status_code)
+        return result
+

bb_integrations_lib/provider/api/platform_science/client.py

@@ -0,0 +1,147 @@
+from datetime import datetime, UTC
+from typing import Self
+
+from httpx import Response
+
+from bb_integrations_lib.gravitate.base_api import BaseAPI
+from bb_integrations_lib.provider.api.platform_science.model import JobDefinition, LoadDefinition
+from bb_integrations_lib.secrets.credential_models import PlatformScienceCredential
+
+
+class PlatformScienceClient(BaseAPI):
+    def __init__(self,
+                 base_url: str,
+                 client_id: str,
+                 client_secret: str
+                 ):
+        super().__init__()
+        self.base_url = base_url
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self._token = None
+
+    def __repr__(self):
+        return "Platform Science API client"
+
+    @classmethod
+    def from_credential(cls, credential: PlatformScienceCredential) -> Self:
+        return cls(
+            base_url=credential.base_url,
+            client_id=credential.client_id,
+            client_secret=credential.client_secret,
+        )
+
+    async def _get_token(self):
+        try:
+            resp = await self.post(
+                url=f"{self.base_url}oauth/token",
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                    "api-version": "2.0"
+                },
+                json={
+                    "grant_type": "client_credentials",
+                    "scope": "admin workflow",
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                }
+            )
+        except Exception:
+            raise ValueError(f"Error getting token from {self.base_url}")
+
+        try:
+            self._token = resp.json()["access_token"]
+            return self._token
+        except Exception:
+            raise ValueError(f"Token response invalid from {self.base_url} -> {resp.status_code}")
+
+    async def _auth_request(self, method: str, **kwargs):
+        if not self._token:
+            await self._get_token()
+
+        headers = kwargs.pop("headers", {})
+        headers["Authorization"] = f"Bearer {self._token}"
+        headers["api-version"] = "2.0"
+        headers["Content-Type"] = "application/json"
+        kwargs["headers"] = headers
+        kwargs["url"] = f"{self.base_url}{kwargs.get('url', '')}"
+        kwargs["timeout"] = kwargs.get("timeout", 90)
+
+        response = await getattr(self, method)(**kwargs)
+
+        if response.status_code == 401:
+            await self._get_token()  # refresh token
+            headers["authorization"] = f"Bearer {self._token}"
+            kwargs["headers"] = headers
+            response = await getattr(self, method)(**kwargs)
+
+        return response
+
+    async def auth_post(self, **kwargs) -> Response:
+        return await self._auth_request("post", **kwargs)
+
+    async def auth_get(self, **kwargs) -> Response:
+        return await self._auth_request("get", **kwargs)
+
+    async def auth_patch(self, **kwargs) -> Response:
+        return await self._auth_request("patch", **kwargs)
+
+    async def auth_put(self, **kwargs) -> Response:
+        return await self._auth_request("put", **kwargs)
+
+    async def auth_delete(self, **kwargs) -> Response:
+        return await self._auth_request("delete", **kwargs)
+
+    async def paginated_get(self, url: str, params: dict | None = None) -> list[dict]:
+        params = params or {}
+        first_page = await self.auth_get(url=url, params=params)
+        if first_page.status_code != 200:
+            raise RuntimeError(f"Error getting assets from {self.base_url}")
+        body = first_page.json()
+        data = body["data"]
+        total_pages = body["meta"]["pagination"]["total_pages"]
+        while body["meta"]["pagination"]["current_page"] < total_pages:
+            params["page"] = body["meta"]["pagination"]["current_page"] + 1
+            next_page = await self.auth_get(url="admin/assets", params=params)
+            body = next_page.json()
+            data.extend(body["data"])
+        return data
+
+    async def get_assets(self) -> list[dict]:
+        return await self.paginated_get(url="admin/assets")
+
+    async def get_drivers(self) -> list[dict]:
+        return await self.paginated_get(url="admin/drivers")
+
+    async def create_assets(self, req: list[dict]) -> Response:
+        return await self.auth_post(url="admin/assets", json=req)
+
+    async def get_amqp_connection(self, channel_name: str):
+        vhost = ""
+        conn_str = f"amqps://{self.client_id}:{self.client_secret}@amqp.pltsci.com:5671/{vhost}"
+
+    async def create_workflow_job(self, driver_id: str, job_definition: JobDefinition) -> Response:
+        return await self.auth_post(url=f"drivers/{driver_id}/jobs", json={
+            "job": job_definition.model_dump(mode="json", exclude_unset=True)
+        })
+
+    async def update_workflow_job(self, driver_id: str, job_id: str, job_definition: JobDefinition) -> Response:
+        return await self.auth_put(url=f"drivers/{driver_id}/jobs/{job_id}", json={
+            "job": job_definition.model_dump(mode="json", exclude_unset=True)
+        })
+
+    async def complete_workflow_job(self, job_id: str, completed_at: datetime | None = None) -> Response:
+        return await self.auth_patch(url=f"jobs/{job_id}/status", json={
+            "status": "tms_completed",
+            "completed_at": (completed_at or datetime.now(tz=UTC)).astimezone(tz=UTC).isoformat()
+        })
+
+    async def delete_workflow_job(self, job_id: str) -> Response:
+        return await self.auth_delete(url=f"jobs/{job_id}/status")
+
+    async def create_load(self, driver_id: str, load_definition: LoadDefinition) -> Response:
+        return await self.auth_post(
+            url=f"admin/drivers/{driver_id}/loads",
+            json=load_definition.model_dump(mode="json", exclude_none=False)
+        )

bb_integrations_lib/provider/api/platform_science/model.py

@@ -0,0 +1,82 @@
+from datetime import datetime, date
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class JobLocation(BaseModel):
+    external_id: str
+    name: str
+    address: str
+    latitude: str
+    longitude: str
+    city: str
+    state: str = Field(min_length=2, max_length=2)
+    country_code: str = Field(min_length=2, max_length=2)
+    postal_code: str | None = None
+    postal_splc:  str | None = None
+    time_zone: Literal["US/Pacific", "US/Arizona", "US/Mountain", "US/Central", "US/Eastern"] | None = None
+
+class JobTaskAppointment(BaseModel):
+    start_time: datetime
+    end_time: datetime
+    ready_time: datetime
+    late_time: datetime | None = None
+
+class JobTask(BaseModel):
+    # external_data: JobTaskExternalData
+    remarks: list[str]
+    fields: dict[str, str]
+    id: str
+    external_id: str
+    order: int = Field(description="Index of the task within the step.")
+    type: str
+    status: str
+    name: str
+    completed: bool
+    completed_at: datetime | None = None
+    assets: str | None = None
+
+class JobStep(BaseModel):
+    tasks: list[JobTask]
+    order: int = Field(description="Index of the step within the job.")
+    type: str
+    name: str
+    external_id: str
+    location_external_id: str
+    completed: bool
+    completed_at: datetime | None = None
+    is_disabled: bool | None = None
+    is_bypassable: bool | None = None
+    is_bypassed: bool | None = None
+    bypass_reason: str | None = None
+    is_reorderable: bool | None = None
+    reorder_reason: str | None = None
+    is_skippable: bool | None = None
+    is_skipped: bool | None = None
+    skip_reason: str | None = None
+
+class ValueWithUnit(BaseModel):
+    value: float
+    uom: str
+
+class ShipmentDetails(BaseModel):
+    total_distance: ValueWithUnit
+
+class JobDefinition(BaseModel):
+    status: str  # TODO: What statuses are possible?
+    external_id: str
+    locations: list[JobLocation]
+    steps: list[JobStep]
+    shipment_details: ShipmentDetails
+
+class LoadEntity(BaseModel):
+    type: Literal["trailer", "bill_of_lading"]
+    value: str
+
+class LoadDefinition(BaseModel):
+    start_date: date
+    end_date: date
+    load: str | None = None
+    user_external_id: str
+    entities: list[LoadEntity]

bb_integrations_lib/provider/api/quicktrip/client.py

@@ -0,0 +1,52 @@
+from typing import Self
+import httpx
+
+from bb_integrations_lib.gravitate.base_api import BaseAPI
+from bb_integrations_lib.secrets.credential_models import QTCredential
+
+
+class QTApiClient(BaseAPI):
+    def __init__(self,
+                 base_url: str,
+                 qt_id: str,
+                 carrier_id: str,
+                 authorization: str):
+        super().__init__()
+        self.base_url = base_url
+        self.qt_id = qt_id
+        self.carrier_id = carrier_id
+        self.authorization = authorization
+
+    @classmethod
+    def from_credential(cls, credential: QTCredential) -> Self:
+        return cls(**credential.model_dump(exclude={"type_tag"}))
+
+    async def get_inventory(self) -> list[dict]:
+        params = {
+        "qtId": self.qt_id,
+            "carrierId": self.carrier_id,
+            "authorization": self.authorization
+        }
+        response = await self.get(
+            f"{self.base_url}/api/ExternalEndpoint/GetLatestCarrierInventory",
+            params=params
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main():
+        client = QTApiClient(
+            base_url="https://petrocorpapi.quiktrip.com",
+            qt_id="EAGN",
+            carrier_id="41",
+            authorization="07572AD2B28DC42410D7CAD4ED126499FDE84F73A7D4A56CE2A1ADBE80117FDD10DC7923E9CFB06BF03FF9251CADD2F2163F7C341E954656FE046F3EC932CD7F"
+        )
+        inventory = await client.get_inventory()
+        print(inventory)
+
+    asyncio.run(main())

bb_integrations_lib/provider/api/telapoint/client.py

@@ -0,0 +1,68 @@
+import httpx
+import loguru
+from bb_integrations_lib.provider.api.telapoint.model import CheckConnectionMethod, SoapEnvelope, OrderGetByOrderNumberMethod, TelapointNewOrder, OrderAdd
+
+namespaces = {
+    'soapenv': "http://schemas.xmlsoap.org/soap/envelope/",
+    'tel': "http://schemas.datacontract.org/2004/07/TelaPoint.Api.TelaFuel.Models",
+    'v2': "http://api.telapoint.com/TelaFuel/v2",
+    'i': "http://www.w3.org/2001/XMLSchema-instance",
+    'wsse': "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd",
+    'wsu': "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+}
+
+
+class TelapointClient(httpx.AsyncClient):
+    def __init__(self, username: str, password: str):
+        super().__init__(
+            base_url="https://api.telapoint.com/APIv2/TelaFuelService.svc",
+            headers={"Content-Type": "text/xml"}
+        )
+        self.base_url = "https://api.telapoint.com/APIv2/TelaFuelService.svc"
+        self.username = username
+        self.password = password
+
+    async def check_connection(self):
+        req = SoapEnvelope.build(self.username, self.password, CheckConnectionMethod)
+
+        response = await super().post(
+            url="",
+            headers={"SOAPAction": "http://api.telapoint.com/TelaFuel/v2/ITelaFuelService/CheckConnection"},
+            content=req.to_xml()
+        )
+        loguru.logger.debug(response.status_code)
+        return response
+
+    async def get_order_by_order_number(self, order_number: str):
+        req = SoapEnvelope.build(self.username, self.password, OrderGetByOrderNumberMethod, order_number=order_number)
+
+        response = await super().post(
+            url="",
+            headers={"SOAPAction": "http://api.telapoint.com/TelaFuel/v2/ITelaFuelService/OrderGetByOrderNumber"},
+            content=req.to_xml()
+        )
+        loguru.logger.debug(response.status_code)
+        return response
+
+    async def create_order(self, new_order: TelapointNewOrder):
+        req = SoapEnvelope.build_with_body(self.username, self.password, OrderAdd, OrderAdd(new_order=new_order))
+
+        response = await super().post(
+            url="",
+            headers={"SOAPAction": "http://api.telapoint.com/TelaFuel/v2/ITelaFuelService/OrderAdd"},
+            content=req.to_xml()
+        )
+        loguru.logger.debug(response.status_code)
+        return response
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main():
+        tc = TelapointClient("<>", "<>")
+        resp = await tc.check_connection()
+        resp = await tc.get_order_by_order_number(order_number="51412828")
+        pass
+
+    asyncio.run(main())

bb_integrations_lib/provider/api/telapoint/model.py

@@ -0,0 +1,178 @@
+from typing import Generic, TypeVar, Type
+
+from pydantic_xml import BaseXmlModel, element, attr
+
+_nsmap = {
+    "soapenv": "http://schemas.xmlsoap.org/soap/envelope/",
+    "tel": "http://schemas.datacontract.org/2004/07/TelaPoint.Api.TelaFuel.Models",
+    "v2": "http://api.telapoint.com/TelaFuel/v2",
+    "i": "http://www.w3.org/2001/XMLSchema-instance",
+    "wsse": "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd",
+    "wsu": "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd",
+}
+
+####################### Copied from pydantic-xml docs for SOAP envelope tech. Probably don't touch.
+
+AuthType = TypeVar('AuthType')
+
+
+class SoapHeader(
+    BaseXmlModel, Generic[AuthType],
+    tag='Header',
+    ns='soapenv',
+    nsmap=_nsmap,
+):
+    auth: AuthType
+
+
+class SoapMethod(BaseXmlModel):
+    pass
+
+
+MethodType = TypeVar('MethodType', bound=SoapMethod)
+
+
+class SoapBody(
+    BaseXmlModel, Generic[MethodType],
+    tag='Body',
+    ns='soapenv',
+    nsmap=_nsmap,
+):
+    call: MethodType
+
+
+HeaderType = TypeVar('HeaderType', bound=SoapHeader)
+BodyType = TypeVar('BodyType', bound=SoapBody)
+
+
+class _Password(BaseXmlModel, tag="Password", ns="wsse", nsmap=_nsmap):
+    type: str = attr("Type",
+                     default="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText")
+    value: str
+
+
+class _UsernameToken(BaseXmlModel, tag="UsernameToken", ns="wsse", nsmap=_nsmap):
+    id: str = attr("Id", ns="wsu", default="uuid-3FE90A72-14E4-29C8-0782-232001AA1234-5")
+    username: str = element("Username", ns="wsse", text=True)
+    password: _Password
+
+
+class Security(
+    BaseXmlModel,
+    tag='Security',
+    ns='wsse',
+    nsmap=_nsmap,
+):
+    must_understand: str = attr("mustUnderstand", ns="wsu", default="1")
+    username_token: _UsernameToken
+
+
+class SoapEnvelope(
+    BaseXmlModel,
+    Generic[MethodType],
+    tag='Envelope',
+    ns='soapenv',
+    nsmap=_nsmap,
+):
+    header: SoapHeader[Security]
+    body: SoapBody[MethodType]
+
+    @classmethod
+    def build(cls, username: str, password: str, method: Type[MethodType], **method_kwargs):
+        return cls[method](
+            header=SoapHeader[Security](
+                auth=Security(
+                    username_token=_UsernameToken(
+                        username=username,
+                        password=_Password(value=password)
+                    )
+                )
+            ),
+            body=SoapBody(call=method(**method_kwargs))
+        )
+
+    @classmethod
+    def build_with_body(cls, username: str, password: str, method: Type[MethodType], body: MethodType):
+        return cls[method](
+            header=SoapHeader[Security](
+                auth=Security(
+                    username_token=_UsernameToken(
+                        username=username,
+                        password=_Password(value=password)
+                    )
+                )
+            ),
+            body=SoapBody(call=body)
+        )
+
+
+################################### End copy from pydantic-xml.
+
+
+"""
+Below this point you can define new methods. These are the things that go in the SOAP body in the request. They are
+regular Pydantic XML models.
+"""
+
+
+class CheckConnectionMethod(SoapMethod, tag="CheckConnection", ns="v2", nsmap=_nsmap):
+    pass
+
+
+class OrderGetByOrderNumberMethod(SoapMethod, tag="OrderGetByOrderNumber", ns="v2", nsmap=_nsmap):
+    order_number: str = element("orderNumber", ns="v2", text=True)
+
+
+class DropProduct(BaseXmlModel, tag="DropProduct", ns="tel", nsmap=_nsmap):
+    logical_tank_guid: str = element("LogicalTankGUID", ns="tel", text=True)
+    order_quantity: int = element("OrderQuantity", ns="tel", text=True)
+    product_guid: str = element("ProductGUID", ns="tel", text=True)
+    source_lift_sequence_number: int = element("SourceLiftSequenceNumber", ns="tel", text=True, default=1)
+
+class DropProducts(BaseXmlModel, tag="OrderDrops", ns="tel", nsmap=_nsmap):
+    drop_products: list[DropProduct] = element("DropProduct", ns="tel")
+
+class OrderDrop(BaseXmlModel, tag="OrderDrop", ns="tel", nsmap=_nsmap):
+    drop_duration: int = element("DropDuration", ns="tel", text=True)
+    drop_products: DropProducts = element("DropProducts", ns="tel")
+    earliest_date_time: str = element("EarliestDateTime", ns="tel", text=True)
+    latest_date_time: str = element("LatestDateTime", ns="tel", text=True)
+    order_type_id: int = element("OrderTypeID", ns="tel", text=True)
+    sequence_number: int = element("SequenceNumber", ns="tel", text=True, default=1)
+    site_guid: str = element("SiteGUID", ns="tel", text=True)
+
+class OrderDrops(BaseXmlModel, tag="OrderDrops", ns="tel", nsmap=_nsmap):
+    order_drops: list[OrderDrop] = element("OrderDrop", ns="tel")
+
+class LiftProduct(BaseXmlModel, tag="LiftProduct", ns="tel", nsmap=_nsmap):
+    order_quantity: int = element("OrderQuantity", ns="tel", text=True)
+    product_guid: str = element("ProductGUID", ns="tel", text=True)
+
+class LiftProducts(BaseXmlModel, tag="LiftProducts", ns="tel", nsmap=_nsmap):
+    lift_products: list[LiftProduct] = element("LiftProduct", ns="tel")
+
+class OrderLift(BaseXmlModel, tag="OrderLift", ns="tel", nsmap=_nsmap):
+    lift_products: LiftProducts = element("LiftProducts", ns="tel")
+    planned_lift_date_time: str = element("PlannedLiftDateTime", ns="tel", text=True)
+    sequence_number: int = element("SequenceNumber", ns="tel", text=True, default=1)
+
+class OrderLifts(BaseXmlModel, tag="OrderLifts", ns="tel", nsmap=_nsmap):
+    order_lifts: list[OrderLift] = element("OrderLift", ns="tel")
+
+class TelapointNewOrder(BaseXmlModel, tag="newOrder", ns="v2", nsmap=_nsmap):
+    bill_to_guid: str = element("BillToGUID", ns="tel", text=True)
+    bill_to_type: str = element("BillToType", ns="tel", text=True)
+    carrier_guid: str = element("CarrierGUID", ns="tel", text=True)
+    freight_lane_guid: str = element("FreightLaneGUID", ns="tel", text=True)
+    order_drops: OrderDrops = element("OrderDrops", ns="tel")
+    order_lifts: OrderLifts = element("OrderLifts", ns="tel")
+    order_status: str = element("OrderStatus", ns="tel", text=True)
+    order_type: str = element("OrderType", ns="tel", text=True)
+    po_number: str = element("PONumber", ns="tel", text=True)
+    parent_company_guid: str = element("ParentCompanyGUID", ns="tel", text=True)
+
+class OrderAdd(SoapMethod, tag="OrderAdd", ns="v2", nsmap=_nsmap):
+    new_order: TelapointNewOrder
+
+class OrderAddResponse(SoapMethod, tag="OrderAddResponse", ns="v2", nsmap=_nsmap):
+    order_add_result: str = element("OrderAddResult", text=True)