ManagerPythonClient 0.0.8__py3-none-any.whl

manager_python_client/Client.py

@@ -0,0 +1,461 @@
+from importlib.metadata import files
+
+import PythonAPIClientBase
+import json
+from urllib.parse import quote
+from uuid import UUID
+import base64
+import mimetypes
+import os
+import requests
+import copy
+from decimal import Decimal
+
+from .SalesInvoiceGenerator import SalesInvoiceGenerator
+from .PurchaseInvoiceGenerator import PurchaseInvoiceGenerator
+from .TransactionReporter import TransactionReporter
+
+
+def json_dump_s_default_function(obj):
+    if isinstance(obj, Decimal):
+        return str(obj)
+    raise TypeError(
+        f"Object of type {type(obj).__name__} is not JSON serializable"
+    )
+
+def nameMatchFunction(item, name):
+    return item["name"] == name
+
+def _get_attachment_url(purchaseInvoiceKey, businessName):
+    name = businessName.encode()
+
+    protobuf = b"\xa2\x06" + bytes([len(name)]) + name
+
+    uuid = UUID(purchaseInvoiceKey)
+
+    protobuf += b"\x0a" + b"\x12"
+    protobuf += b"\x09" + uuid.bytes_le[:8]
+    protobuf += b"\x11" + uuid.bytes_le[8:]
+
+    encoded = base64.urlsafe_b64encode(protobuf).decode().rstrip("=")
+
+    return f"/new-attachment?{encoded}"
+
+class ManagerClient(PythonAPIClientBase.APIClientBase):
+    debug = None
+    def __init__(self, baseUrl, mock=None, forceOneRequestAtATime=False, verboseLogging=PythonAPIClientBase.VerboseLoggingNullLogClass(), debug=False):
+        self.debug = debug
+        useBaseUrl = baseUrl
+        if useBaseUrl != "MOCK":
+            useBaseUrl = useBaseUrl
+        super().__init__(baseURL=useBaseUrl, mock=mock, forceOneRequestAtATime=forceOneRequestAtATime, verboseLogging=verboseLogging)
+
+    def is_online(self):
+        try:
+            response = self.sendGetRequest(
+                url="/",
+                loginSession=None
+            )
+        except PythonAPIClientBase.APIClientException as cli:
+            if cli.result.status_code == 401:
+                return True # running but not authed as we have no login session
+            return False
+        except Exception as exp:
+            print("Other exp", exp)
+            return False
+        return True
+
+    def _get_generator(self, loginSession, apiObj, outputKey=None, enrichParams=None, skipFn=None):
+        if outputKey is None:
+            outputKey = apiObj
+        pageSize = 100
+        skip = 0
+        while True:
+            params = {
+                "pageSize": pageSize,
+                "skip": skip
+            }
+            if enrichParams is not None:
+                enrichParams(params)
+            response = self.sendGetRequest(
+                url=f"/{apiObj}",
+                loginSession=loginSession,
+                params=params
+            )
+            if response.status_code != 200:
+                print("status_code=", response.status_code)
+                raise Exception("Error getting " + apiObj)
+            data = json.loads(response.text)
+            # print("D", data)
+            if outputKey not in data:
+                print("Possible keys", data.keys())
+                raise Exception("given output key not possible - " + outputKey)
+            customers = data[outputKey]
+            for customer in customers:
+                skip = False
+                if skipFn is not None:
+                    skip = skipFn(customer)
+                if not skip:
+                    yield customer
+            if len(customers) < pageSize:
+                break
+            skip += pageSize
+
+    def _get_single(self, loginSession, name, apiObj, outputKey=None, matchFn=nameMatchFunction):
+        if outputKey is None:
+            outputKey = apiObj
+        response = self.sendGetRequest(
+            url=f"/{apiObj}?term={quote(name)}",
+            loginSession=loginSession
+        )
+        if response.status_code != 200:
+            raise Exception("Error getting " + apiObj)
+        data = json.loads(response.text)
+        if len(data[outputKey]) == 0:
+            return None
+        retItems = []
+        for item in data[outputKey]:
+            if matchFn(item, name):
+                retItems.append(item)
+        if len(retItems) == 0:
+            return None
+        if len(retItems) == 1:
+            return retItems[0]
+        return None # only return if we have a unique match
+
+
+    def get_customers(self, loginSession):
+        return self._get_generator(loginSession, "customers")
+    def get_customer(self, loginSession, name):
+        return self._get_single(loginSession, name, "customers")
+
+    def get_suppliers(self, loginSession):
+        return self._get_generator(loginSession, "suppliers")
+    def get_supplier(self, loginSession, name):
+        return self._get_single(loginSession, name, "suppliers")
+
+    def get_bank_and_cash_accounts(self, loginSession):
+        return self._get_generator(loginSession, "bank-and-cash-accounts", "bankAndCashAccounts")
+    def get_bank_and_cash_account(self, loginSession, name):
+        return self._get_single(loginSession, name, "bank-and-cash-accounts", "bankAndCashAccounts")
+
+    def get_chart_of_accounts(self, loginSession):
+        return self._get_generator(loginSession, "chart-of-accounts", "chartOfAccounts")
+    def get_chart_of_account(self, loginSession, name):
+        return self._get_single(loginSession, name, "chart-of-accounts", "chartOfAccounts")
+
+    def get_sales_invoices(self, loginSession):
+        return self._get_generator(loginSession, "sales-invoices", "salesInvoices")
+    def get_sales_invoices_for_customer(self, loginSession, customerName):
+        def skipFn(sales_invoice):
+            if customerName != sales_invoice["customer"]:
+                return True
+            return False
+        return self._get_generator(loginSession, "sales-invoices", "salesInvoices", skipFn=skipFn)
+    def get_sales_invoice(self, loginSession, description, customerName):
+        def nameMatchFunction(item, name):
+            if item["customer"] != customerName:
+                return False
+            if item["description"] != description:
+                return False
+            return True
+        return self._get_single(loginSession, description, "sales-invoices", "salesInvoices", matchFn=nameMatchFunction)
+
+    def get_inter_account_transfer_for_description(self, loginSession, description):
+        def enrichParams(params):
+            params["term"] = description
+        # def skipFn(rec):
+        #     if date == rec["date"]:
+        #         return False
+        #     return True
+        return self._get_generator(
+            loginSession,
+            "inter-account-transfers",
+            "interAccountTransfers",
+            enrichParams=enrichParams
+        )
+
+
+    def get_purchase_invoices(self, loginSession):
+        return self._get_generator(loginSession, "purchase-invoices", "purchaseInvoices")
+    def get_purchase_invoices_for_supplier(self, loginSession, supplierName):
+        def skipFn(purchase_invoice):
+            if supplierName != purchase_invoice["supplier"]:
+                return True
+            return False
+        return self._get_generator(loginSession, "purchase-invoices", "purchaseInvoices", skipFn=skipFn)
+    def get_purchase_invoice(self, loginSession, description, supplierName):
+        def nameMatchFunction(item, name):
+            if item["supplier"] != supplierName:
+                return False
+            if item["description"] != description:
+                return False
+            return True
+        return self._get_single(loginSession, description, "purchase-invoices", "purchaseInvoices", matchFn=nameMatchFunction)
+
+    def get_payment_for_description(self, loginSession, description):
+        def enrichParams(params):
+            params["term"] = description
+        # def skipFn(rec):
+        #     if date == rec["date"]:
+        #         return False
+        #     return True
+        return self._get_generator(
+            loginSession,
+            "payments",
+            "payments",
+            enrichParams=enrichParams
+        )
+
+    def create_sales_invoice_generator(self, issueDate, reference, customerKey, billingAddress, description):
+        return SalesInvoiceGenerator(issueDate, reference, customerKey, billingAddress, description)
+
+    def create_sales_invoice(self, loginSession, generator):
+        if not isinstance(generator, SalesInvoiceGenerator):
+            raise Exception("Wrong type of generator")
+        hasLineDescription = False
+        for line in generator.lines:
+            accountKey, description, qty, unit_price = line
+            if description is not None and description != "":
+                hasLineDescription = True
+        postData = {
+            "IssueDate": generator.issueDate,
+            "Reference": generator.reference,
+            "Customer": generator.customerKey,
+            "BillingAddress": generator.billingAddress,
+            "Description": generator.description,
+            "HasLineDescription": hasLineDescription,
+            "Lines": []
+        }
+        if len(generator.lines) == 0:
+            raise Exception("No lines found")
+
+        for line in generator.lines:
+            accountKey, description, qty, unit_price = line
+            postData["Lines"].append({
+                "Account": accountKey,
+                "LineDescription": description,
+                "Qty": qty,
+                "SalesUnitPrice": unit_price
+            })
+        response = self.sendPostRequest(
+            url="/sales-invoice-form",
+            loginSession=loginSession,
+            data=json.dumps(postData, default=json_dump_s_default_function)
+        )
+        if response.status_code != 201:
+            raise Exception("Error creating sales invoice")
+        data = json.loads(response.text)
+        return data
+
+    def pay_sales_invoice(self, loginSession, date, recievedAccountKey, description, accountKey, accountRecivablesCustomer, salesInvoiceKey, amount):
+        postData = {
+            "Date": date,
+            "ReceivedIn": recievedAccountKey,
+            "Description": description,
+            "PaidBy": 1,
+            "Customer": accountRecivablesCustomer,
+            "Lines": [
+                {
+                    "Account": accountKey,
+                    "AccountsReceivableCustomer": accountRecivablesCustomer,
+                    "AccountsReceivableSalesInvoice": salesInvoiceKey,
+                    "Amount": amount
+                }
+            ]
+        }
+        response = self.sendPostRequest(
+            url="/receipt-form",
+            loginSession=loginSession,
+            data=json.dumps(postData, default=json_dump_s_default_function)
+        )
+        if response.status_code != 201:
+            raise Exception("Error creating sales invoice payment")
+        data = json.loads(response.text)
+        return data
+
+    def get_receipt_for_description(self, loginSession, description):
+        def enrichParams(params):
+            params["term"] = description
+        # def skipFn(rec):
+        #     if date == rec["date"]:
+        #         return False
+        #     return True
+        return self._get_generator(
+            loginSession,
+            "receipts",
+            "receipts",
+            enrichParams=enrichParams
+        )
+
+    def create_purchase_invoice_generator(self, issueDate, reference, supplierKey, description):
+        return PurchaseInvoiceGenerator(issueDate, reference, supplierKey, description)
+
+    def create_purchase_invoice(self, loginSession, generator):
+        if not isinstance(generator, PurchaseInvoiceGenerator):
+            raise Exception("Wrong type of generator")
+        hasLineDescription = False
+        for line in generator.lines:
+            accountKey, description, qty, unit_price = line
+            if description is not None and description != "":
+                hasLineDescription = True
+        postData = {
+            "IssueDate": generator.issueDate,
+            "Reference": generator.reference,
+            "Supplier": generator.supplierKey,
+            "Description": generator.description,
+            "HasLineDescription": hasLineDescription,
+            "Lines": []
+        }
+        if len(generator.lines) == 0:
+            raise Exception("No lines found")
+
+        for line in generator.lines:
+            accountKey, description, qty, unit_price = line
+            postData["Lines"].append({
+                "Account": accountKey,
+                "LineDescription": description,
+                "Qty": qty,
+                "PurchaseUnitPrice": unit_price
+            })
+        response = self.sendPostRequest(
+            url="/purchase-invoice-form",
+            loginSession=loginSession,
+            data=json.dumps(postData, default=json_dump_s_default_function)
+        )
+        if response.status_code != 201:
+            raise Exception("Error creating sales invoice")
+        data = json.loads(response.text)
+        return data
+
+    def pay_purchase_invoice(self, loginSession, date, paidFromAccountKey, description, accountKey, accountPayableSupplier, purchaseInvoiceKey, amount):
+        postData = {
+            "Date": date,
+            "PaidFrom": paidFromAccountKey,
+            "Description": description,
+            "Payee": 2,
+            "Supplier": accountPayableSupplier,
+            "Lines": [
+                {
+                    "Account": accountKey,
+                    "AccountsPayableSupplier": accountPayableSupplier,
+                    "PurchaseInvoice": purchaseInvoiceKey,
+                    "Amount": amount
+                }
+            ]
+        }
+        response = self.sendPostRequest(
+            url="/payment-form",
+            loginSession=loginSession,
+            data=json.dumps(postData, default=json_dump_s_default_function)
+        )
+        if response.status_code != 201:
+            raise Exception("Error creating purchase invoice payment")
+        data = json.loads(response.text)
+        return data
+
+    def create_inter_account_transfer(
+        self,
+        loginSession,
+        date,
+        reference,
+        paidFromAccountKey,
+        receivedInAccountKey,
+        description,
+        amount
+    ):
+        postData = {
+            "Date": date,
+            "Reference": reference,
+            "PaidFrom": paidFromAccountKey,
+            "ReceivedIn": receivedInAccountKey,
+            "Description": description,
+            "CreditAmount": amount,
+            "DebitAmount": amount
+        }
+
+        response = self.sendPostRequest(
+            url="/inter-account-transfer-form",
+            loginSession=loginSession,
+            data=json.dumps(postData, default=json_dump_s_default_function)
+        )
+
+        if response.status_code != 201:
+            raise Exception(
+                f"Error creating inter account transfer: "
+                f"{response.status_code} {response.text}"
+            )
+
+        return json.loads(response.text)
+
+    def get_business(self, loginSession):
+        response = self.sendGetRequest(
+            url="/access-tokens?pageSize=1",
+            loginSession=loginSession
+        )
+        if response.status_code != 200:
+            raise Exception(
+                f"Error getting business name: "
+                f"{response.status_code} {response.text}"
+            )
+        data = json.loads(response.text)
+        return data["business"]
+
+    def attach_to_purchase_invoice(
+            self,
+            loginSession,
+            purchaseInvoiceKey,
+            filename,
+            fileData,
+            fileType=None
+    ):
+        import mimetypes
+        import os
+        fileNameToSend = os.path.basename(filename)
+        fileNameToSend = quote(fileNameToSend, safe="")
+        if fileType is None:
+            fileType, _ = mimetypes.guess_type(fileNameToSend)
+            if fileType is None:
+                fileType = "application/octet-stream"
+        business = self.get_business(loginSession)
+        url = (self.baseURL + _get_attachment_url(
+            purchaseInvoiceKey,
+            business["name"]
+        )).replace("/api2/", "/")
+
+        headers = {
+            "Content-Type": "application/octet-stream",
+            "X-File-Name": fileNameToSend,
+            "X-File-Type": fileType,
+        }
+        if loginSession is not None:
+            loginSession.injectHeaders(headers)
+
+        response = requests.post(
+            url=url,
+            data=fileData,   # raw bytes, not files=
+            headers=headers
+        )
+        if response.status_code not in (200, 201):
+            raise Exception(
+                f"Error uploading attachment: "
+                f"{response.status_code} {response.text}"
+            )
+        data = json.loads(response.text)
+        return data
+
+    def get_transaction_reporter(self, loginSession):
+        def enrichParams(params):
+            params["fields"] = ["Date", "Transaction", "Reference", "BankOrCashAccount", "Customer",
+                "Supplier", "Employee",
+                "Description", "Item", "Account", "BalanceSheetAccount", "ProfitAndLossStatementAccount",
+                "LineDescription", "Qty", "UnitPrice", "Project", "Division", "TaxCode", "TaxAmount",
+                "Debit", "Credit", "Amount", "Timestamp"
+            ]
+        gen = self._get_generator(
+            loginSession,
+            "transactions",
+            enrichParams=enrichParams
+            #,outputKey="balanceSheetTransactions"
+        )
+        return TransactionReporter(gen)

manager_python_client/ExpectedEntry/ExpectedEntryBase.py

@@ -0,0 +1,96 @@
+
+
+class ExpectedEntryBase:
+    def __init__(self, companyObj, date, description):
+        self.companyObj = companyObj
+        self.date = date
+        self.description = description
+        self.checkRun = False
+        self.isPresent = False
+        self.correctionProcessWasRun = False
+        self.matched_item = None
+
+    def _get_start_output_line(self):
+        retVal = ""
+        if self.is_correctable():
+            retVal += "CANCOR "
+        else:
+            if self.isPresent:
+                if self.correctionProcessWasRun:
+                    retVal += "FIXED  "
+                else:
+                    retVal += "OK     "
+            else:
+                retVal += "       "
+        retVal += (self.companyObj["shortName"] + "     ")[:3] + " "
+        retVal += self.date + " "
+        retVal += self.__class__.__name__[13:] + " "
+        return retVal
+
+    def get_user_output_line(self):
+        retVal = self._get_start_output_line()
+        retVal += self.description + " "
+        retVal += str(self.amount) + " "
+        return retVal
+
+    def check(self, client, recheck=False):
+        if not recheck:
+            if self.checkRun:
+                return # Already checked
+        res = self._check(client)
+        if res is None:
+            return
+        self.isPresent = res
+        self.checkRun = True
+
+    def _checkOutcomeStr(self):
+        if not self.checkRun:
+            return ""
+        if self.isPresent:
+            return "✅ Found Entry"
+        return "❌ Missing"
+    # Checks the entry to see if it can be found
+    def _check(self, client):
+        raise Exception("__check Not Overridden in " + self.__class__.__name__)
+
+    def is_correctable(self):
+        if not self.checkRun:
+            return False
+        if self.isPresent:
+            return False # No need to correct
+        return self._is_correctable()
+
+
+    def correct(self, client):
+        if not self.is_correctable():
+            return 0
+        if self.isPresent:
+            raise Exception("It is correctable but element already present")
+        if self.correctionProcessWasRun:
+            raise Exception("Trying to correct twice")
+        num = self._correct(client)
+        self.check(client, recheck=True)
+        if not self.isPresent:
+            print("ERROR WHEN TRYING CORRECTION")
+            print(self.get_user_output_line())
+            print("")
+            raise Exception("Did not find created entry - bad error")
+        self.correctionProcessWasRun = True
+        return num
+
+
+    # Override these both together
+    def _is_correctable(self):
+        return False
+    def _correct(self, client):
+        raise Exception("Not Overridden")
+        #return 1 #num records corrected
+
+    def _save_matched_item(self, item):
+        self.matched_item = item
+
+    def get_matched_item(self):
+        return self.matched_item
+
+    # def sorting_weight(self):
+    #     return 100

manager_python_client/ExpectedEntry/ExpectedEntryInterAccountTransfer.py

@@ -0,0 +1,50 @@
+
+from .ExpectedEntryBase import ExpectedEntryBase
+
+
+class ExpectedEntryInterAccountTransfer(ExpectedEntryBase):
+    def __init__(self, companyObj, date, paidFromAccount, description, amount, receivedInAccount, reference):
+        # reference, billingAddress needed for creation
+        super().__init__(companyObj, date, description)
+
+        # Extra match on fields
+        self.paidFromAccount = paidFromAccount
+        self.receivedInAccount = receivedInAccount
+        self.amount = amount
+
+        # Other fields needed for creation
+        self.reference = reference
+
+    def get_user_output_line(self):
+        retVal = self._get_start_output_line()
+        retVal += "From " + self.paidFromAccount["name"]
+        retVal += " -> " + self.receivedInAccount["name"] + " "
+        retVal += str(self.amount) + " "
+        retVal += "   " + self._checkOutcomeStr()
+        return retVal
+
+    def _check(self, client):
+        transfers = client.get_inter_account_transfer_for_description(self.companyObj["loginSession"], self.description)
+        for transfer in transfers:
+            # description already matched
+            # Has to match date amount paidFromAccount receivedInAccount
+            if transfer["date"] == self.date:
+                if transfer["amount"]["value"] == self.amount:
+                    if transfer["paidFrom"] == self.paidFromAccount["name"]:
+                        if transfer["receivedIn"] == self.receivedInAccount["name"]:
+                            return True
+        return False
+
+    def _is_correctable(self):
+        return True
+    def _correct(self, client):
+        transfer_result = client.create_inter_account_transfer(
+            loginSession=self.companyObj["loginSession"],
+            date=self.date,
+            reference=self.reference,
+            paidFromAccountKey=self.paidFromAccount["key"],
+            receivedInAccountKey=self.receivedInAccount["key"],
+            description=self.description,
+            amount=self.amount
+        )
+        return 1 #num records corrected

manager_python_client/ExpectedEntry/ExpectedEntryPurchaseInvoice.py

@@ -0,0 +1,109 @@
+from .ExpectedEntryBase import ExpectedEntryBase
+
+
+class ExpectedEntryPurchaseInvoice(ExpectedEntryBase):
+    def __init__(self, companyObj, date, description, supplier, reference, account, lineDescription, qty, unitPrice, requiredAttachements=0, attachements=[]):
+        # reference, billingAddress needed for creation
+        super().__init__(companyObj, date, description)
+
+        # Extra match on fields
+        self.supplier = supplier
+        self.account = account
+        self.qty = qty
+        self.unitPrice = unitPrice
+
+        # Other fields needed for creation
+        self.reference = reference
+        self.lineDescription = lineDescription
+
+        self.requiredAttachements = requiredAttachements
+        self.attachements = attachements
+        if not isinstance(self.attachements, list):
+            raise Exception("Attachements should be a list")
+        for (filename, filedata) in self.attachements:
+            if not isinstance(filename, str):
+                raise Exception("Attachment Filename should be a string")
+            if not isinstance(filedata, bytes):
+                print("Got type", filedata.__class__)
+                raise Exception("Attachment filedata should be a x")
+
+
+    # purchaseInvoiceGenerator = client.create_purchase_invoice_generator(
+    #     issueDate="2026-02-25",
+    #     reference="REF" + random_string,
+    #     supplierKey=supplier["key"],
+    #     description=invoiceDescription
+    # )
+    # purchaseInvoiceGenerator.addLine(
+    #     accountKey=expenseAccount["key"],
+    #     description="Thing I really wanted",
+    #     qty=1,
+    #     unit_price=purchaseInvoiceAmount
+    # )
+
+    def get_user_output_line(self):
+        retVal = self._get_start_output_line()
+        retVal += self.supplier["name"] + " "
+        retVal += self.description + " "
+        retVal += str(self.qty) + "x" + str(self.unitPrice) + " "
+        retVal += "(" + self.account["name"] + ") "
+        retVal += "   " + self._checkOutcomeStr()
+        return retVal
+
+    def _check(self, client):
+        # fields to match
+        # date
+        # description
+        # self.supplier = supplier
+        # self.account = account # Not going to be able to match on line account
+        # self.qty = qty
+        # self.unitPrice = unitPrice
+        invoices = client.get_purchase_invoices_for_supplier(self.companyObj["loginSession"], self.supplier["name"])
+        for invoice in invoices:
+            if invoice["issueDate"] == self.date:
+                if invoice["description"] == self.description:
+                    if invoice["invoiceAmount"]["value"] == self.get_total_amount():
+                        self._save_matched_item(invoice)
+                        return True
+
+        return False
+
+    def get_name(self):
+        # Used in payment get_user_output_line display
+        return self.supplier["name"]
+
+    def get_total_amount(self):
+        return self.qty * self.unitPrice
+
+    def _is_correctable(self):
+        if len(self.attachements) != self.requiredAttachements:
+            return False
+        return True # False for now change later
+    def _correct(self, client):
+        purchaseInvoiceGenerator = client.create_purchase_invoice_generator(
+            issueDate=self.date,
+            reference=self.reference,
+            supplierKey=self.supplier["key"],
+            description=self.description
+        )
+        purchaseInvoiceGenerator.addLine(
+            accountKey=self.account["key"],
+            description=self.lineDescription,
+            qty=self.qty,
+            unit_price=self.unitPrice
+        )
+        purchase_result = client.create_purchase_invoice(self.companyObj["loginSession"], purchaseInvoiceGenerator)
+        self._save_matched_item(purchase_result)
+
+        for (filename, filedata) in self.attachements:
+            upload_attach_result = client.attach_to_purchase_invoice(
+                loginSession=self.companyObj["loginSession"],
+                purchaseInvoiceKey=purchase_result["Key"],
+                filename=filename,
+                fileData=filedata,
+                fileType=None # will guess if none is provided
+            )
+        return 1 #num records corrected
+
+    def sorting_weight(self):
+        return 50 # must before purchase invoice payments

manager_python_client/ExpectedEntry/ExpectedEntryPurchaseInvoicePayment.py

@@ -0,0 +1,75 @@
+from .ExpectedEntryBase import ExpectedEntryBase
+from .ExpectedEntryPurchaseInvoice import ExpectedEntryPurchaseInvoice
+
+class ExpectedEntryPurchaseInvoicePayment(ExpectedEntryBase):
+    def __init__(self, companyObj, date, description, paidFromAccount, accountPayableSupplier, account, amount, purchaseInvoice):
+        # reference, billingAddress needed for creation
+        super().__init__(companyObj, date, description)
+
+        # Extra match on fields
+        self.paidFromAccount = paidFromAccount
+        self.accountPayableSupplier = accountPayableSupplier
+        self.amount = amount
+
+        # Other fields needed for creation
+        self.account = account # e.g. accounts payable
+        self.purchaseInvoice = purchaseInvoice
+        if not isinstance(purchaseInvoice, ExpectedEntryPurchaseInvoice):
+            raise Exception("Must have a purchase invoice to relate to")
+        if self.companyObj["name"] != self.purchaseInvoice.companyObj["name"]:
+            raise Exception("Purchase Invoice does not belong to the same company")
+        if self.amount != self.purchaseInvoice.get_total_amount():
+            raise Exception ("Purchase invoice NOT being paid in full")
+
+    # purchaseInvoicePaymentResult = client.pay_purchase_invoice(
+    #     loginSession=testBusinessLoginSesison,
+    #     date="2026-02-25",
+    #     paidFromAccountKey=rebloutCashAccount["key"],
+    #     description="pay Desc",
+    #     accountKey=accountsPayable["key"],
+    #     accountPayableSupplier=supplier["key"],
+    #     purchaseInvoiceKey=purchase_result["Key"],
+    #     amount=purchaseInvoiceAmount
+    # )
+
+    def get_user_output_line(self):
+        retVal = self._get_start_output_line()
+        retVal += "Paying " + self.purchaseInvoice.get_name() + " "
+        retVal += self.paidFromAccount["name"] + " "
+        retVal += self.description + " "
+        retVal += str(self.amount) + " "
+        retVal += "(" + self.account["name"] + ") "
+        retVal += "   " + self._checkOutcomeStr()
+        return retVal
+
+    def _check(self, client):
+        # fields to match
+        # date
+        # description
+        # self.paidFromAccount = paidFromAccount
+        # self.accountPayableSupplier = accountPayableSupplier
+        # self.amount = amount
+        payments = client.get_payment_for_description(self.companyObj["loginSession"], self.description)
+        for payment in payments:
+            #print("purchase invoice Payment Match Debug", payment)
+            if payment["date"] == self.date:
+                if payment["paidFrom"] == self.paidFromAccount["name"]:
+                    if payment["payee"] == self.accountPayableSupplier["name"]:
+                        if payment["amount"]["value"] == self.amount:
+                            return True
+        return False
+
+    def _is_correctable(self):
+        return True
+    def _correct(self, client):
+        purchaseInvoicePaymentResult = client.pay_purchase_invoice(
+            loginSession=self.companyObj["loginSession"],
+            date=self.date,
+            paidFromAccountKey=self.paidFromAccount["key"],
+            description=self.description,
+            accountKey=self.account["key"],
+            accountPayableSupplier=self.accountPayableSupplier["key"],
+            purchaseInvoiceKey=self.purchaseInvoice.get_matched_item()["key"],
+            amount=self.amount
+        )
+        return 1 #num records corrected

manager_python_client/ExpectedEntry/ExpectedEntrySalesInvoice.py

@@ -0,0 +1,88 @@
+from .ExpectedEntryBase import ExpectedEntryBase
+
+
+class ExpectedEntrySalesInvoice(ExpectedEntryBase):
+    def __init__(self, companyObj, issueDate, description, customer, reference, billingAddress, account, lineDescription, qty, unitPrice):
+        # reference, billingAddress needed for creation
+        super().__init__(companyObj, date=issueDate, description=description)
+
+        # Extra match on fields
+        self.customer = customer
+        self.account = account
+        self.qty = qty
+        self.unitPrice = unitPrice
+
+        # Other fields needed for creation
+        self.reference = reference
+        self.lineDescription = lineDescription
+        self.billingAddress = billingAddress
+
+    # salesInvoiceGenerator = client.create_sales_invoice_generator(
+    #     issueDate="2026-01-31",
+    #     reference="REF",
+    #     customerKey=customer["key"],
+    #     billingAddress="One the road\nthe street\nth towh, DF3 F45",
+    #     description=invoiceDescription
+    # )
+    # salesInvoiceGenerator.addLine(
+    #     accountKey=account["key"],
+    #     description="TODO",
+    #     qty=2,
+    #     unit_price=12.34
+    # )
+
+    def get_user_output_line(self):
+        retVal = self._get_start_output_line()
+        retVal += self.customer["name"] + " "
+        retVal += self.description + " "
+        retVal += str(self.qty) + "x" + str(self.unitPrice) + " "
+        retVal += "(" + self.account["name"] + ") "
+        retVal += "   " + self._checkOutcomeStr()
+        return retVal
+
+    def _check(self, client):
+        # fields to match
+        # date
+        # description
+        # self.customer = customer
+        # self.account = account # Not going to be able to match on line account
+        # self.qty = qty
+        # self.unitPrice = unitPrice
+        invoices = client.get_sales_invoices_for_customer(self.companyObj["loginSession"], self.customer["name"])
+        for invoice in invoices:
+            if invoice["issueDate"] == self.date:
+                if invoice["description"] == self.description:
+                    if invoice["invoiceAmount"]["value"] == self.get_total_amount():
+                        self._save_matched_item(invoice)
+                        return True
+        return False
+
+    def get_name(self):
+        # Used in payment get_user_output_line display
+        return self.customer["name"]
+
+    def get_total_amount(self):
+        return self.qty * self.unitPrice
+
+    def _is_correctable(self):
+        return True
+    def _correct(self, client):
+        salesInvoiceGenerator = client.create_sales_invoice_generator(
+            issueDate=self.date,
+            reference=self.reference,
+            customerKey=self.customer["key"],
+            billingAddress=self.billingAddress,
+            description=self.description
+        )
+        salesInvoiceGenerator.addLine(
+            accountKey=self.account["key"],
+            description=self.lineDescription,
+            qty=self.qty,
+            unit_price=self.unitPrice
+        )
+        sales_invoice_info = client.create_sales_invoice(self.companyObj["loginSession"], salesInvoiceGenerator)
+        self._save_matched_item(sales_invoice_info)
+        return 1
+
+    def sorting_weight(self):
+        return 50 # must before purchase invoice patments

manager_python_client/ExpectedEntry/ExpectedEntrySalesInvoiceReceipt.py

@@ -0,0 +1,76 @@
+from .ExpectedEntryBase import ExpectedEntryBase
+from .ExpectedEntrySalesInvoice import ExpectedEntrySalesInvoice
+
+class ExpectedEntrySalesInvoiceReceipt(ExpectedEntryBase):
+    def __init__(self, companyObj, date, description, receivedAccount, accountRecivablesCustomer, account, amount, salesInvoice):
+        super().__init__(companyObj, date, description)
+
+        # Extra match on fields
+        self.receivedAccount = receivedAccount
+        self.accountReceivablesCustomer = accountRecivablesCustomer
+        self.amount = amount
+
+        # Other fields needed for creation
+        self.account = account # e.g. accounts payable
+        self.salesInvoice = salesInvoice
+        if not isinstance(salesInvoice, ExpectedEntrySalesInvoice):
+            raise Exception("Must have a sales invoice to relate to")
+        if self.companyObj["name"] != self.salesInvoice.companyObj["name"]:
+            raise Exception("Sales Invoice does not belong to the same company")
+        if self.amount != self.salesInvoice.get_total_amount():
+            raise Exception ("Sales invoice NOT being paid in full")
+
+    # result = client.pay_sales_invoice(
+    #     loginSession=testBusinessLoginSesison,
+    #     date="2026-11-30",
+    #     recievedAccountKey=rebloutCashAccount["key"],
+    #     description="pay Desc",
+    #     accountKey=accountsRecievable["key"],
+    #     accountReceivablesCustomer=customer["key"],
+    #     salesInvoiceKey=looked_up_sales_invoice["key"],
+    #     amount=1.01
+    # )
+
+
+    def get_user_output_line(self):
+        retVal = self._get_start_output_line()
+        retVal += "Paying " + self.salesInvoice.get_name() + " "
+        retVal += self.receivedAccount["name"] + " "
+        retVal += self.description + " "
+        retVal += str(self.amount) + " "
+        retVal += "(" + self.account["name"] + ") "
+        retVal += "   " + self._checkOutcomeStr()
+        return retVal
+
+    def _check(self, client):
+        # fields to match
+        # date
+        # description
+        # self.receivedAccount = receivedAccount
+        # self.accountReceivablesCustomer = accountReceivablesCustomer
+        # self.amount = amount
+        # Paid By is always going to be None
+        payments = client.get_receipt_for_description(self.companyObj["loginSession"], self.description)
+        for payment in payments:
+            ##print("sales invoice receipt Match Debug", payment)
+            if payment["date"] == self.date:
+                if payment["paidBy"] == self.accountReceivablesCustomer["name"]:
+                    if payment["receivedIn"]["key"] == self.receivedAccount["key"]:
+                        if payment["amount"]["value"] == self.amount:
+                            return True
+        return False
+
+    def _is_correctable(self):
+        return True
+    def _correct(self, client):
+        result = client.pay_sales_invoice(
+            loginSession=self.companyObj["loginSession"],
+            date=self.date,
+            recievedAccountKey=self.receivedAccount["key"],
+            description=self.description,
+            accountKey=self.account["key"],
+            accountRecivablesCustomer=self.accountReceivablesCustomer["key"],
+            salesInvoiceKey=self.salesInvoice.get_matched_item()["key"],
+            amount=self.amount
+        )
+        return 1 #num records corrected

manager_python_client/ExpectedEntry/Pattern.py

@@ -0,0 +1,48 @@
+
+
+
+class Pattern:
+    entries = None
+    key = None
+    def __init__(self,key):
+        self.entries = []
+        self.key = key
+    def add_entry(self, expected_entry):
+        self.entries.append(expected_entry)
+
+    def get_key(self):
+        return self.key
+
+    def get_user_output(self):
+        retVal = ""
+
+        for entry in self.entries:
+            retVal += entry.get_user_output_line() + "\n"
+
+        return retVal
+
+    def check_all_enteries(self, client):
+        for entry in self.entries:
+            entry.check(client)
+
+    def num_correctable_entries(self, client):
+        self.check_all_enteries(client)
+        retVal =0
+        for entry in self.entries:
+            if entry.is_correctable():
+                retVal += 1
+        return retVal
+
+    def is_correctable(self, client):
+        self.check_all_enteries(client)
+        for entry in self.entries:
+            if not entry.is_correctable():
+                return False
+        return True
+
+    def run_corrections(self, client):
+        number_corrected = 0
+        ##self.entries.sort(key=lambda entry: entry.sorting_weight())
+        for entry in self.entries:
+            number_corrected += entry.correct(client)
+        return number_corrected

manager_python_client/ExpectedEntry/__init__.py

@@ -0,0 +1,6 @@
+from .Pattern import Pattern
+from .ExpectedEntrySalesInvoice import ExpectedEntrySalesInvoice
+from .ExpectedEntryInterAccountTransfer import ExpectedEntryInterAccountTransfer
+from .ExpectedEntryPurchaseInvoice import ExpectedEntryPurchaseInvoice
+from .ExpectedEntryPurchaseInvoicePayment import ExpectedEntryPurchaseInvoicePayment
+from .ExpectedEntrySalesInvoiceReceipt import ExpectedEntrySalesInvoiceReceipt

manager_python_client/ManagerLoginSession.py

@@ -0,0 +1,18 @@
+from PythonAPIClientBase import LoginSession
+
+class ManagerLoginSession(LoginSession):
+    token = None
+    def __init__(self, client, token):
+        self.client = client
+        self.token = token
+
+    def injectHeaders(self, headers):
+        headers["X-API-KEY"] = self.token
+
+    def refresh(self):
+        return False
+
+
+class ManagerLoginSessionFromAuthToken(ManagerLoginSession):
+    def __init__(self, client, access_token):
+        super().__init__(client=client, token=access_token)

manager_python_client/PurchaseInvoiceGenerator.py

@@ -0,0 +1,13 @@
+
+
+class PurchaseInvoiceGenerator:
+    lines = None
+    def __init__(self, issueDate, reference, supplierKey, description):
+        self.issueDate = issueDate
+        self.reference = reference
+        self.supplierKey = supplierKey
+        self.description = description
+        self.lines = []
+
+    def addLine(self, accountKey, description, qty, unit_price):
+        self.lines.append((accountKey, description, qty, unit_price))

manager_python_client/SalesInvoiceGenerator.py

@@ -0,0 +1,14 @@
+
+
+class SalesInvoiceGenerator:
+    lines = None
+    def __init__(self, issueDate, reference, customerKey, billingAddress, description):
+        self.issueDate = issueDate
+        self.reference = reference
+        self.customerKey = customerKey
+        self.billingAddress = billingAddress
+        self.description = description
+        self.lines = []
+
+    def addLine(self, accountKey, description, qty, unit_price):
+        self.lines.append((accountKey, description, qty, unit_price))

manager_python_client/TransactionReporter.py

@@ -0,0 +1,48 @@
+from decimal import Decimal
+
+CASH_ACCOUNT_NAME = "Cash & cash equivalents"
+
+class TransactionReporter:
+    mainData = None
+    # Dict, first key is the name of the bankOrCashAccount
+    def __init__(self, generator):
+        self.mainData = {}
+        for transaction in generator:
+            transaction["amount"] = Decimal(str(transaction["amount"]))
+            if transaction["bankOrCashAccount"] not in self.mainData:
+                self.mainData[transaction["bankOrCashAccount"]] = []
+            self.mainData[transaction["bankOrCashAccount"]].append(transaction)
+
+    def get_bank_or_cash_accounts(self):
+        return [account for account in self.mainData if account is not None]
+
+    def get_bank_or_cash_account_entries(self, bankOrCashAccountName):
+        if bankOrCashAccountName not in self.mainData:
+            raise Exception("bankOrCashAccountName not found")
+        retVal = []
+        for entry in self.mainData[bankOrCashAccountName]:
+            if entry["account"] == CASH_ACCOUNT_NAME:
+                retVal.append(entry)
+        return sorted(retVal, key=lambda entry: entry["date"])
+
+    def get_customer_receipts(self, customerName):
+        retVal = []
+        for account in self.mainData.keys():
+            if account is not None:
+                for entry in self.mainData[account]:
+                    if entry["transaction"] == "Receipt":
+                        if entry["customer"] == customerName:
+                            if entry["account"] == CASH_ACCOUNT_NAME:
+                                retVal.append(entry)
+        return sorted(retVal, key=lambda entry: entry["date"])
+
+    def get_supplier_payments(self, supplierName):
+        retVal = []
+        for account in self.mainData.keys():
+            if account is not None:
+                for entry in self.mainData[account]:
+                    if entry["transaction"] == "Payment":
+                        if entry["supplier"] == supplierName:
+                            if entry["account"] == CASH_ACCOUNT_NAME:
+                                retVal.append(entry)
+        return sorted(retVal, key=lambda entry: entry["date"])

manager_python_client/__init__.py

@@ -0,0 +1,7 @@
+from .ManagerLoginSession import ManagerLoginSessionFromAuthToken
+from .Client import ManagerClient
+from .ExpectedEntry import Pattern, ExpectedEntrySalesInvoice, ExpectedEntryInterAccountTransfer, ExpectedEntryPurchaseInvoice, ExpectedEntryPurchaseInvoicePayment, ExpectedEntrySalesInvoiceReceipt
+
+def hello_world() -> str:
+    """Return the library's initial greeting."""
+    return "Hello, world!"

managerpythonclient-0.0.8.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.5
+Name: ManagerPythonClient
+Version: 0.0.8
+Summary: Manager python client for accessing API.
+Project-URL: Homepage, https://github.com/rmetcalf9/ManagerPythonClient
+Project-URL: Repository, https://github.com/rmetcalf9/ManagerPythonClient
+Author: Robert Metcalf
+License: MIT License
+        
+        Copyright (c) 2026 Robert Metcalf
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: inquirerpy==0.3.4
+Requires-Dist: pythonapiclientbase==0.0.19
+Description-Content-Type: text/markdown
+
+# Python client for Manager API
+
+## Development
+
+Run the tests with:
+
+```bash
+uv run --with pytest pytest
+```
+
+Build the distribution with:
+
+```bash
+uv build
+```
+
+## Release
+
+use release.sh

managerpythonclient-0.0.8.dist-info/RECORD

@@ -0,0 +1,18 @@
+manager_python_client/Client.py,sha256=RkQ5JxRj9kcQPgHM2ZAeDvqqhUL9j9Y2HrKZWXKaGLo,17323
+manager_python_client/ManagerLoginSession.py,sha256=2Yh7sg1rOz5Vl7yreJOg2rs75Ips6DvwflPGFu5I6zc,494
+manager_python_client/PurchaseInvoiceGenerator.py,sha256=tqLfDH2-8cyn5Wdb0meUFkpd7F-m5ZIri0r7eyLsDhs,431
+manager_python_client/SalesInvoiceGenerator.py,sha256=haDXdKEYYFX887CAtSqdQiPBWURIA6X-Gd9Vb94_NI8,489
+manager_python_client/TransactionReporter.py,sha256=G0E6NjnYbkKD-bUZMZN25xoKq5xvQg3QSoajVnmtUjI,2138
+manager_python_client/__init__.py,sha256=1HV81Wo_THzZoRHubyu4muB2j2Qca3hYo-I1F81FIuI,401
+manager_python_client/ExpectedEntry/ExpectedEntryBase.py,sha256=FxQbuvTdQXaO8CvgcRMg5KvnNtG8AWq4oCnzEtfFmos,2921
+manager_python_client/ExpectedEntry/ExpectedEntryInterAccountTransfer.py,sha256=LJte0MT85nFIEh7LSevwehz0QJQGWFNYTHcB_wYesYY,2044
+manager_python_client/ExpectedEntry/ExpectedEntryPurchaseInvoice.py,sha256=T9NPeErOYdo3-ZPbFIO2x9U9FndvBY8FtWKhI54Zizo,4284
+manager_python_client/ExpectedEntry/ExpectedEntryPurchaseInvoicePayment.py,sha256=RizfiVohV5BJ3WWHXW0W1ZQx9IhByCKigw-WKVCzyEs,3416
+manager_python_client/ExpectedEntry/ExpectedEntrySalesInvoice.py,sha256=tun6gMS4hcVg3LZN3qbcxbKLq_WrSfu0uW0QAUwvorg,3276
+manager_python_client/ExpectedEntry/ExpectedEntrySalesInvoiceReceipt.py,sha256=WnsqHKtIQAp3WlyIbJEdfFhfwFL56onxMFLZKisPnGA,3340
+manager_python_client/ExpectedEntry/Pattern.py,sha256=YL3EiCOD9b_IARnDDFtc3UJ1z0DaT-9LmM1P-C3EuGE,1237
+manager_python_client/ExpectedEntry/__init__.py,sha256=ji1JulYKLCLkumsqQG4dZ0v08LwTuREKXcVBF7NiGds,410
+managerpythonclient-0.0.8.dist-info/METADATA,sha256=S2ToKeFgFEbSI9togGQZWvALC8w9GqX72IwTHdudYQ0,2270
+managerpythonclient-0.0.8.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+managerpythonclient-0.0.8.dist-info/licenses/LICENSE,sha256=ODtATG_0rj1J6X6amg9J_EU-Re2PnJX88IE_vyH6GSA,1071
+managerpythonclient-0.0.8.dist-info/RECORD,,

managerpythonclient-0.0.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

managerpythonclient-0.0.8.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Metcalf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.