sevdesk 0.1.0__py3-none-any.whl

sevdesk/__init__.py

@@ -0,0 +1,3 @@
+VERSION = "0.1.0"
+
+from sevdesk.client import Client

sevdesk/base/basecontroller.py

@@ -0,0 +1,102 @@
+import inspect
+from typing import get_type_hints, get_origin, get_args
+
+class BaseController:
+    def __init__(self, client):
+        self.client = client
+    
+    @staticmethod
+    def parse_response(response, return_type):
+        """Wandelt die Response in das entsprechende Model um"""
+        if return_type is None:
+            return response
+        
+        # Hole den ursprünglichen Typ (ohne list[] wrapper)
+        origin = get_origin(return_type)
+        
+        # Wenn es eine Liste ist
+        if origin is list:
+            args = get_args(return_type)
+            if args:
+                model_class = args[0]
+                # Response sollte eine Liste von Dicts sein
+                if isinstance(response, dict) and 'objects' in response:
+                    # sevDesk API struktur: {"objects": [...]}
+                    return [model_class(**item) if isinstance(item, dict) else item 
+                            for item in response['objects']]
+                elif isinstance(response, list):
+                    return [model_class(**item) if isinstance(item, dict) else item 
+                            for item in response]
+        
+        # Einzelnes Model
+        elif hasattr(return_type, '__bases__'):  # Check if it's a class
+            if isinstance(response, dict):
+                # sevDesk API struktur kann auch {"objects": {...}} sein
+                if 'objects' in response and isinstance(response['objects'], dict):
+                    return return_type(**response['objects'])
+                else:
+                    return return_type(**response)
+        
+        return response
+    
+    @staticmethod
+    def request(method, path):
+        def decorator(func):
+            def wrapper(self, *args, **kwargs):
+                # Args in kwargs umwandeln
+                sig = inspect.signature(func)
+                bound_args = sig.bind(self, *args, **kwargs)
+                bound_args.apply_defaults()
+                
+                # Entferne 'self' aus den arguments
+                all_kwargs = dict(bound_args.arguments)
+                all_kwargs.pop('self', None)
+                
+                gen = func(self, **all_kwargs)
+                
+                try:
+                    # Pre-request: bis zum yield ausführen
+                    next(gen)
+                    # veränderte parameter übernehmen
+                    for arg in all_kwargs.copy():
+                        # gi_frame HACK
+                        if gen.gi_frame:
+                            all_kwargs[arg] = gen.gi_frame.f_locals[arg]
+                    
+                    response = self.client.request(method, path, all_kwargs)
+                    
+                    # Return Type aus der Funktion auslesen
+                    try:
+                        type_hints = get_type_hints(func)
+                        return_type = type_hints.get('return', None)
+                    except Exception:
+                        return_type = None
+                    
+                    # Response in Model umwandeln
+                    parsed_response = BaseController.parse_response(response, return_type)
+                    
+                    # Gebe das Ergebnis direkt zurück
+                    return parsed_response
+                    
+                except StopIteration:
+                    return None
+                    
+            wrapper.__name__ = func.__name__
+            return wrapper
+        return decorator
+
+    @staticmethod
+    def get(path):
+        return BaseController.request('get', path)
+
+    @staticmethod
+    def post(path):
+        return BaseController.request('post', path)
+
+    @staticmethod
+    def put(path):
+        return BaseController.request('put', path)
+
+    @staticmethod
+    def delete(path):
+        return BaseController.request('delete', path)

sevdesk/client.py

@@ -0,0 +1,81 @@
+import requests
+import re
+import importlib
+from pathlib import Path
+
+class Client:
+
+    def __init__(self, api_token, api_base='https://my.sevdesk.de/api/v1', session=None):
+        self.api_token = api_token
+        self.api_base = api_base
+        self.session = session
+        if not self.session:
+            self.session = requests.Session()
+
+        # Automatisch alle Controller laden
+        self._load_controllers()
+
+    def _load_controllers(self):
+        """Lädt automatisch alle Controller aus dem controllers Verzeichnis"""
+        controllers_dir = Path(__file__).parent / "controllers"
+        
+        if not controllers_dir.exists():
+            return
+        
+        for controller_file in controllers_dir.glob("*_controller.py"):
+            # z.B. "contact_controller.py" -> "contact"
+            controller_name = controller_file.stem.replace("_controller", "")
+            
+            try:
+                # Dynamisch importieren
+                module = importlib.import_module(f"sevdesk.controllers.{controller_file.stem}")
+                
+                # Finde die Controller-Klasse im Modul (endet mit "Controller")
+                controller_class = None
+                for attr_name in dir(module):
+                    attr = getattr(module, attr_name)
+                    if (isinstance(attr, type) and 
+                        attr_name.endswith("Controller") and 
+                        attr_name != "BaseController"):
+                        controller_class = attr
+                        break
+                
+                if controller_class:
+                    # Als Attribut setzen: self.contact = ContactController(self)
+                    setattr(self, controller_name, controller_class(self))
+                else:
+                    print(f"Warning: No controller class found in {controller_file.stem}")
+                
+            except (ImportError, AttributeError) as e:
+                print(f"Warning: Could not load controller {controller_name}: {e}")
+
+    def request(self, method, path, params):
+        url_params = re.findall(r"{(\w+)}", path)
+        request_path = path.format(**params)
+        
+        request_params = {
+            k: v for k, v in params.items()
+            if k not in url_params and
+            k != 'body' and
+            v} # v not None
+        request_url = f'{self.api_base}{request_path}'
+        request_body = params.get('body', None)
+        if request_body:
+            request_body = request_body.model_dump(by_alias=True, exclude_none=True)
+
+        # print('request_params', request_params)
+        # print('request_url', request_url)
+        # print('request_body', request_body)
+
+        response = self.session.request(
+            method=method,
+            url=request_url,
+            params=request_params,
+            json=request_body,
+            headers={
+                'Authorization': self.api_token
+            }
+        )
+        # print(response.status_code)
+        # print(response.text)
+        return response.json()

sevdesk/controllers/accountingcontact_controller.py

@@ -0,0 +1,33 @@
+from sevdesk.base.basecontroller import BaseController
+from typing import Optional
+from sevdesk.models.accountingcontact import AccountingContact
+from sevdesk.models.accountingcontactresponse import AccountingContactResponse
+from sevdesk.models.accountingcontactupdate import AccountingContactUpdate
+
+class AccountingContactController(BaseController):
+
+    @BaseController.get("/AccountingContact")
+    def getAccountingContact(self, contact_id: Optional[str] = None, contact_objectName: Optional[str] = None) -> list[AccountingContactResponse]:
+        """Retrieve accounting contact"""
+        return (yield)
+
+    @BaseController.post("/AccountingContact")
+    def createAccountingContact(self, body: AccountingContact) -> AccountingContactResponse:
+        """Create a new accounting contact"""
+        return (yield)
+
+    @BaseController.get("/AccountingContact/{accountingContactId}")
+    def getAccountingContactById(self, accountingContactId: int) -> list[AccountingContactResponse]:
+        """Find accounting contact by ID"""
+        return (yield)
+
+    @BaseController.put("/AccountingContact/{accountingContactId}")
+    def updateAccountingContact(self, accountingContactId: int, body: AccountingContactUpdate) -> AccountingContactResponse:
+        """Update an existing accounting contact"""
+        return (yield)
+
+    @BaseController.delete("/AccountingContact/{accountingContactId}")
+    def deleteAccountingContact(self, accountingContactId: int):
+        """Deletes an accounting contact"""
+        return (yield)
+

sevdesk/controllers/basics_controller.py

@@ -0,0 +1,9 @@
+from sevdesk.base.basecontroller import BaseController
+
+class BasicsController(BaseController):
+
+    @BaseController.get("/Tools/bookkeepingSystemVersion")
+    def bookkeepingSystemVersion(self):
+        """Retrieve bookkeeping system version"""
+        return (yield)
+

sevdesk/controllers/checkaccount_controller.py

@@ -0,0 +1,45 @@
+from sevdesk.base.basecontroller import BaseController
+from sevdesk.models.checkaccountresponse import CheckAccountResponse
+from sevdesk.models.checkaccountupdate import CheckAccountUpdate
+from sevdesk.models.createclearingaccount import CreateClearingAccount
+from sevdesk.models.createclearingaccountresponse import CreateClearingAccountResponse
+from sevdesk.models.createfileimportaccount import CreateFileImportAccount
+from sevdesk.models.createfileimportaccountresponse import CreateFileImportAccountResponse
+
+class CheckAccountController(BaseController):
+
+    @BaseController.get("/CheckAccount")
+    def getCheckAccounts(self) -> list[CheckAccountResponse]:
+        """Retrieve check accounts"""
+        return (yield)
+
+    @BaseController.post("/CheckAccount/Factory/fileImportAccount")
+    def createFileImportAccount(self, body: CreateFileImportAccount) -> CreateFileImportAccountResponse:
+        """Create a new file import account"""
+        return (yield)
+
+    @BaseController.post("/CheckAccount/Factory/clearingAccount")
+    def createClearingAccount(self, body: CreateClearingAccount) -> CreateClearingAccountResponse:
+        """Create a new clearing account"""
+        return (yield)
+
+    @BaseController.get("/CheckAccount/{checkAccountId}")
+    def getCheckAccountById(self, checkAccountId: int) -> list[CheckAccountResponse]:
+        """Find check account by ID"""
+        return (yield)
+
+    @BaseController.put("/CheckAccount/{checkAccountId}")
+    def updateCheckAccount(self, checkAccountId: int, body: CheckAccountUpdate) -> CheckAccountResponse:
+        """Update an existing check account"""
+        return (yield)
+
+    @BaseController.delete("/CheckAccount/{checkAccountId}")
+    def deleteCheckAccount(self, checkAccountId: int):
+        """Deletes a check account"""
+        return (yield)
+
+    @BaseController.get("/CheckAccount/{checkAccountId}/getBalanceAtDate")
+    def getBalanceAtDate(self, checkAccountId: int, date: str):
+        """Get the balance at a given date"""
+        return (yield)
+

sevdesk/controllers/checkaccounttransaction_controller.py

@@ -0,0 +1,38 @@
+from sevdesk.base.basecontroller import BaseController
+from typing import Optional
+from sevdesk.models.checkaccounttransaction import CheckAccountTransaction
+from sevdesk.models.checkaccounttransactionresponse import CheckAccountTransactionResponse
+from sevdesk.models.checkaccounttransactionupdate import CheckAccountTransactionUpdate
+
+class CheckAccountTransactionController(BaseController):
+
+    @BaseController.get("/CheckAccountTransaction")
+    def getTransactions(self, checkAccount_id: Optional[int] = None, checkAccount_objectName: Optional[str] = None, endDate: Optional[str] = None, isBooked: Optional[bool] = None, onlyCredit: Optional[bool] = None, onlyDebit: Optional[bool] = None, payeePayerName: Optional[str] = None, paymtPurpose: Optional[str] = None, startDate: Optional[str] = None) -> list[CheckAccountTransactionResponse]:
+        """Retrieve transactions"""
+        return (yield)
+
+    @BaseController.post("/CheckAccountTransaction")
+    def createTransaction(self, body: CheckAccountTransaction) -> CheckAccountTransactionResponse:
+        """Create a new transaction"""
+        return (yield)
+
+    @BaseController.get("/CheckAccountTransaction/{checkAccountTransactionId}")
+    def getCheckAccountTransactionById(self, checkAccountTransactionId: int) -> list[CheckAccountTransactionResponse]:
+        """Find check account transaction by ID"""
+        return (yield)
+
+    @BaseController.put("/CheckAccountTransaction/{checkAccountTransactionId}")
+    def updateCheckAccountTransaction(self, checkAccountTransactionId: int, body: CheckAccountTransactionUpdate) -> CheckAccountTransactionResponse:
+        """Update an existing check account transaction"""
+        return (yield)
+
+    @BaseController.delete("/CheckAccountTransaction/{checkAccountTransactionId}")
+    def deleteCheckAccountTransaction(self, checkAccountTransactionId: int):
+        """Deletes a check account transaction"""
+        return (yield)
+
+    @BaseController.put("/CheckAccountTransaction/{checkAccountTransactionId}/enshrine")
+    def checkAccountTransactionEnshrine(self, checkAccountTransactionId: int):
+        """Enshrine"""
+        return (yield)
+

sevdesk/controllers/communicationway_controller.py

@@ -0,0 +1,38 @@
+from sevdesk.base.basecontroller import BaseController
+from typing import Optional
+from sevdesk.models.communicationway import CommunicationWay
+from sevdesk.models.communicationwayresponse import CommunicationWayResponse
+from sevdesk.models.communicationwayupdate import CommunicationWayUpdate
+
+class CommunicationWayController(BaseController):
+
+    @BaseController.get("/CommunicationWay")
+    def getCommunicationWays(self, contact_id: Optional[str] = None, contact_objectName: Optional[str] = None, main: Optional[str] = None, type_: Optional[str] = None) -> list[CommunicationWayResponse]:
+        """Retrieve communication ways"""
+        return (yield)
+
+    @BaseController.post("/CommunicationWay")
+    def createCommunicationWay(self, body: CommunicationWay) -> CommunicationWayResponse:
+        """Create a new contact communication way"""
+        return (yield)
+
+    @BaseController.get("/CommunicationWay/{communicationWayId}")
+    def getCommunicationWayById(self, communicationWayId: int) -> list[CommunicationWayResponse]:
+        """Find communication way by ID"""
+        return (yield)
+
+    @BaseController.delete("/CommunicationWay/{communicationWayId}")
+    def deleteCommunicationWay(self, communicationWayId: int):
+        """Deletes a communication way"""
+        return (yield)
+
+    @BaseController.put("/CommunicationWay/{communicationWayId}")
+    def UpdateCommunicationWay(self, communicationWayId: int, body: CommunicationWayUpdate) -> CommunicationWayResponse:
+        """Update a existing communication way"""
+        return (yield)
+
+    @BaseController.get("/CommunicationWayKey")
+    def getCommunicationWayKeys(self):
+        """Retrieve communication way keys"""
+        return (yield)
+

sevdesk/controllers/contact_controller.py

@@ -0,0 +1,53 @@
+from sevdesk.base.basecontroller import BaseController
+from typing import Optional
+from sevdesk.models.contact import Contact
+from sevdesk.models.contactresponse import ContactResponse
+from sevdesk.models.contactupdate import ContactUpdate
+
+class ContactController(BaseController):
+
+    @BaseController.get("/Contact/Factory/getNextCustomerNumber")
+    def getNextCustomerNumber(self):
+        """Get next free customer number"""
+        return (yield)
+
+    @BaseController.get("/Contact/Factory/findContactsByCustomFieldValue")
+    def findContactsByCustomFieldValue(self, customFieldName: str, value: str, customFieldSetting_id: Optional[str] = None, customFieldSetting_objectName: Optional[str] = None) -> list[ContactResponse]:
+        """Find contacts by custom field value"""
+        return (yield)
+
+    @BaseController.get("/Contact/Mapper/checkCustomerNumberAvailability")
+    def contactCustomerNumberAvailabilityCheck(self, customerNumber: Optional[str] = None):
+        """Check if a customer number is available"""
+        return (yield)
+
+    @BaseController.get("/Contact")
+    def getContacts(self, customerNumber: Optional[str] = None, depth: Optional[str] = None) -> list[ContactResponse]:
+        """Retrieve contacts"""
+        return (yield)
+
+    @BaseController.post("/Contact")
+    def createContact(self, body: Contact) -> ContactResponse:
+        """Create a new contact"""
+        return (yield)
+
+    @BaseController.get("/Contact/{contactId}")
+    def getContactById(self, contactId: int) -> list[ContactResponse]:
+        """Find contact by ID"""
+        return (yield)
+
+    @BaseController.put("/Contact/{contactId}")
+    def updateContact(self, contactId: int, body: ContactUpdate) -> ContactResponse:
+        """Update a existing contact"""
+        return (yield)
+
+    @BaseController.delete("/Contact/{contactId}")
+    def deleteContact(self, contactId: int):
+        """Deletes a contact"""
+        return (yield)
+
+    @BaseController.get("/Contact/{contactId}/getTabsItemCount")
+    def getContactTabsItemCountById(self, contactId: int):
+        """Get number of all items"""
+        return (yield)
+

sevdesk/controllers/contactaddress_controller.py

@@ -0,0 +1,32 @@
+from sevdesk.base.basecontroller import BaseController
+from sevdesk.models.contactaddress import ContactAddress
+from sevdesk.models.contactaddressresponse import ContactAddressResponse
+from sevdesk.models.contactaddressupdate import ContactAddressUpdate
+
+class ContactAddressController(BaseController):
+
+    @BaseController.post("/ContactAddress")
+    def createContactAddress(self, body: ContactAddress) -> ContactAddressResponse:
+        """Create a new contact address"""
+        return (yield)
+
+    @BaseController.get("/ContactAddress")
+    def getContactAddresses(self) -> list[ContactAddressResponse]:
+        """Retrieve contact addresses"""
+        return (yield)
+
+    @BaseController.get("/ContactAddress/{contactAddressId}")
+    def contactAddressId(self, contactAddressId: int) -> list[ContactAddressResponse]:
+        """Find contact address by ID"""
+        return (yield)
+
+    @BaseController.put("/ContactAddress/{contactAddressId}")
+    def updateContactAddress(self, contactAddressId: int, body: ContactAddressUpdate) -> ContactAddressResponse:
+        """update a existing contact address"""
+        return (yield)
+
+    @BaseController.delete("/ContactAddress/{contactAddressId}")
+    def deleteContactAddress(self, contactAddressId: int):
+        """Deletes a contact address"""
+        return (yield)
+

sevdesk/controllers/contactfield_controller.py

@@ -0,0 +1,72 @@
+from sevdesk.base.basecontroller import BaseController
+from typing import Optional
+from sevdesk.models.contactcustomfield import ContactCustomField
+from sevdesk.models.contactcustomfieldresponse import ContactCustomFieldResponse
+from sevdesk.models.contactcustomfieldsetting import ContactCustomFieldSetting
+from sevdesk.models.contactcustomfieldsettingresponse import ContactCustomFieldSettingResponse
+from sevdesk.models.contactcustomfieldsettingupdate import ContactCustomFieldSettingUpdate
+from sevdesk.models.contactcustomfieldupdate import ContactCustomFieldUpdate
+from sevdesk.models.textparser_fetchdictionaryentriesbytype_response import Textparser_fetchDictionaryEntriesByType_response
+
+class ContactFieldController(BaseController):
+
+    @BaseController.get("/Textparser/fetchDictionaryEntriesByType")
+    def getPlaceholder(self, objectName: str, subObjectName: Optional[str] = None) -> list[Textparser_fetchDictionaryEntriesByType_response]:
+        """Retrieve Placeholders"""
+        return (yield)
+
+    @BaseController.get("/ContactCustomField")
+    def getContactFields(self) -> list[ContactCustomFieldResponse]:
+        """Retrieve contact fields"""
+        return (yield)
+
+    @BaseController.post("/ContactCustomField")
+    def createContactField(self, body: ContactCustomField) -> ContactCustomFieldResponse:
+        """Create contact field"""
+        return (yield)
+
+    @BaseController.get("/ContactCustomField/{contactCustomFieldId}")
+    def getContactFieldsById(self, contactCustomFieldId: float) -> list[ContactCustomFieldResponse]:
+        """Retrieve contact fields"""
+        return (yield)
+
+    @BaseController.put("/ContactCustomField/{contactCustomFieldId}")
+    def updateContactfield(self, contactCustomFieldId: float, body: ContactCustomFieldUpdate) -> ContactCustomFieldResponse:
+        """Update a contact field"""
+        return (yield)
+
+    @BaseController.delete("/ContactCustomField/{contactCustomFieldId}")
+    def deleteContactCustomFieldId(self, contactCustomFieldId: int):
+        """delete a contact field"""
+        return (yield)
+
+    @BaseController.get("/ContactCustomFieldSetting")
+    def getContactFieldSettings(self) -> list[ContactCustomFieldSettingResponse]:
+        """Retrieve contact field settings"""
+        return (yield)
+
+    @BaseController.post("/ContactCustomFieldSetting")
+    def createContactFieldSetting(self, body: ContactCustomFieldSetting) -> list[ContactCustomFieldSettingResponse]:
+        """Create contact field setting"""
+        return (yield)
+
+    @BaseController.get("/ContactCustomFieldSetting/{contactCustomFieldSettingId}")
+    def getContactFieldSettingById(self, contactCustomFieldSettingId: int) -> list[ContactCustomFieldSettingResponse]:
+        """Find contact field setting by ID"""
+        return (yield)
+
+    @BaseController.put("/ContactCustomFieldSetting/{contactCustomFieldSettingId}")
+    def updateContactFieldSetting(self, contactCustomFieldSettingId: int, body: ContactCustomFieldSettingUpdate) -> ContactCustomFieldSettingResponse:
+        """Update contact field setting"""
+        return (yield)
+
+    @BaseController.delete("/ContactCustomFieldSetting/{contactCustomFieldSettingId}")
+    def deleteContactFieldSetting(self, contactCustomFieldSettingId: int):
+        """Deletes a contact field setting"""
+        return (yield)
+
+    @BaseController.get("/ContactCustomFieldSetting/{contactCustomFieldSettingId}/getReferenceCount")
+    def getReferenceCount(self, contactCustomFieldSettingId: int):
+        """Receive count reference"""
+        return (yield)
+

sevdesk/controllers/creditnote_controller.py

@@ -0,0 +1,86 @@
+from sevdesk.base.basecontroller import BaseController
+from typing import Optional
+from sevdesk.models.creditnoteresponse import CreditNoteResponse
+from sevdesk.models.creditnoteupdate import CreditNoteUpdate
+from sevdesk.models.creditnote_mailresponse import CreditNote_mailResponse
+from sevdesk.models.creditnote_sendbywithrender import CreditNote_sendByWithRender
+from sevdesk.models.savecreditnote import SaveCreditNote
+from sevdesk.models.savecreditnoteresponse import SaveCreditNoteResponse
+
+class CreditNoteController(BaseController):
+
+    @BaseController.get("/CreditNote")
+    def getCreditNotes(self, contact_id: Optional[int] = None, contact_objectName: Optional[str] = None, creditNoteNumber: Optional[str] = None, endDate: Optional[int] = None, startDate: Optional[int] = None, status: Optional[str] = None) -> list[CreditNoteResponse]:
+        """Retrieve CreditNote"""
+        return (yield)
+
+    @BaseController.post("/CreditNote/Factory/saveCreditNote")
+    def createcreditNote(self, body: SaveCreditNote) -> SaveCreditNoteResponse:
+        """Create a new creditNote"""
+        return (yield)
+
+    @BaseController.post("/CreditNote/Factory/createFromInvoice")
+    def createCreditNoteFromInvoice(self):
+        """Creates a new creditNote from an invoice"""
+        return (yield)
+
+    @BaseController.post("/CreditNote/Factory/createFromVoucher")
+    def createCreditNoteFromVoucher(self):
+        """Creates a new creditNote from a voucher"""
+        return (yield)
+
+    @BaseController.get("/CreditNote/{creditNoteId}")
+    def getcreditNoteById(self, creditNoteId: int) -> list[CreditNoteResponse]:
+        """Find creditNote by ID"""
+        return (yield)
+
+    @BaseController.put("/CreditNote/{creditNoteId}")
+    def updatecreditNote(self, creditNoteId: int, body: CreditNoteUpdate) -> CreditNoteResponse:
+        """Update an existing creditNote"""
+        return (yield)
+
+    @BaseController.delete("/CreditNote/{creditNoteId}")
+    def deletecreditNote(self, creditNoteId: int):
+        """Deletes an creditNote"""
+        return (yield)
+
+    @BaseController.get("/CreditNote/{creditNoteId}/sendByWithRender")
+    def sendCreditNoteByPrinting(self, creditNoteId: int, sendType: str) -> CreditNote_sendByWithRender:
+        """Send credit note by printing"""
+        return (yield)
+
+    @BaseController.put("/CreditNote/{creditNoteId}/sendBy")
+    def creditNoteSendBy(self, creditNoteId: int) -> CreditNoteResponse:
+        """Mark credit note as sent"""
+        return (yield)
+
+    @BaseController.put("/CreditNote/{creditNoteId}/enshrine")
+    def creditNoteEnshrine(self, creditNoteId: int):
+        """Enshrine"""
+        return (yield)
+
+    @BaseController.get("/CreditNote/{creditNoteId}/getPdf")
+    def creditNoteGetPdf(self, creditNoteId: int, download: Optional[bool] = None, preventSendBy: Optional[bool] = None):
+        """Retrieve pdf document of a credit note"""
+        return (yield)
+
+    @BaseController.post("/CreditNote/{creditNoteId}/sendViaEmail")
+    def sendCreditNoteViaEMail(self, creditNoteId: int) -> list[CreditNote_mailResponse]:
+        """Send credit note via email"""
+        return (yield)
+
+    @BaseController.put("/CreditNote/{creditNoteId}/bookAmount")
+    def bookCreditNote(self, creditNoteId: int):
+        """Book a credit note"""
+        return (yield)
+
+    @BaseController.put("/CreditNote/{creditNoteId}/resetToOpen")
+    def creditNoteResetToOpen(self, creditNoteId: int):
+        """Reset status to open"""
+        return (yield)
+
+    @BaseController.put("/CreditNote/{creditNoteId}/resetToDraft")
+    def creditNoteResetToDraft(self, creditNoteId: int):
+        """Reset status to draft"""
+        return (yield)
+

sevdesk/controllers/creditnotepos_controller.py

@@ -0,0 +1,11 @@
+from sevdesk.base.basecontroller import BaseController
+from typing import Optional
+from sevdesk.models.creditnoteposresponse import CreditNotePosResponse
+
+class CreditNotePosController(BaseController):
+
+    @BaseController.get("/CreditNotePos")
+    def getcreditNotePositions(self, creditNote_id: Optional[int] = None, creditNote_objectName: Optional[str] = None) -> list[CreditNotePosResponse]:
+        """Retrieve creditNote positions"""
+        return (yield)
+