zepben.ewb 1.0.0__py3-none-any.whl

zepben/ewb/database/sqlite/customer/customer_cim_reader.py

@@ -0,0 +1,169 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerCimReader"]
+
+from typing import Callable
+
+from zepben.ewb.database.sqlite.common.base_cim_reader import BaseCimReader
+from zepben.ewb.database.sqlite.extensions.result_set import ResultSet
+from zepben.ewb.database.sqlite.tables.associations.table_customer_agreements_pricing_structures import TableCustomerAgreementsPricingStructures
+from zepben.ewb.database.sqlite.tables.associations.table_pricing_structures_tariffs import TablePricingStructuresTariffs
+from zepben.ewb.database.sqlite.tables.iec61968.common.table_agreements import TableAgreements
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customer_agreements import TableCustomerAgreements
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customers import TableCustomers
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_pricing_structures import TablePricingStructures
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_tariffs import TableTariffs
+from zepben.ewb.model.cim.iec61968.common.agreement import Agreement
+from zepben.ewb.model.cim.iec61968.customers.customer import Customer
+from zepben.ewb.model.cim.iec61968.customers.customer_agreement import CustomerAgreement
+from zepben.ewb.model.cim.iec61968.customers.customer_kind import CustomerKind
+from zepben.ewb.model.cim.iec61968.customers.pricing_structure import PricingStructure
+from zepben.ewb.model.cim.iec61968.customers.tariff import Tariff
+from zepben.ewb.services.customer.customers import CustomerService
+
+class CustomerCimReader(BaseCimReader):
+    """
+    A class for reading the `CustomerService` tables from the database.
+
+    :param service: The `CustomerService` to populate from the database.
+    """
+
+    def __init__(self, service: CustomerService):
+        super().__init__(service)
+        self._service: CustomerService
+
+    ###################
+    # IEC61968 Common #
+    ###################
+
+    def _load_agreement(self, agreement: Agreement, table: TableAgreements, result_set: ResultSet) -> bool:
+        return self._load_document(agreement, table, result_set)
+
+    ######################
+    # IEC61968 Customers #
+    ######################
+
+    def load_customers(self, table: TableCustomers, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `Customer` and populate its fields from `TableCustomers`.
+
+        :param table: The database table to read the `Customer` fields from.
+        :param result_set: The record in the database table containing the fields for this `Customer`.
+        :param set_identifier: A callback to register the mRID of this `Customer` for logging purposes.
+
+        :return: True if the `Customer` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        customer = Customer(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
+
+        customer.kind = CustomerKind[result_set.get_string(table.kind.query_index)]
+        # Currently unused customer.num_end_devices = rs.get_int(table.num_end_devices.query_index, None)
+        customer.special_need = result_set.get_string(table.special_need.query_index, on_none=None)
+
+        return self._load_organisation_role(customer, table, result_set) and self._add_or_throw(customer)
+
+    def load_customer_agreements(self, table: TableCustomerAgreements, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `CustomerAgreement` and populate its fields from `TableCustomerAgreements`.
+
+        :param table: The database table to read the `CustomerAgreement` fields from.
+        :param result_set: The record in the database table containing the fields for this `CustomerAgreement`.
+        :param set_identifier: A callback to register the mRID of this `CustomerAgreement` for logging purposes.
+
+        :return: True if the `CustomerAgreement` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        customer_agreement = CustomerAgreement(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
+
+        customer_agreement.customer = self._ensure_get(
+            result_set.get_string(table.customer_mrid.query_index, on_none=None),
+            Customer
+        )
+        if customer_agreement.customer is not None:
+            customer_agreement.customer.add_agreement(customer_agreement)
+
+        return self._load_agreement(customer_agreement, table, result_set) and self._add_or_throw(customer_agreement)
+
+    def load_pricing_structures(self, table: TablePricingStructures, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `PricingStructure` and populate its fields from `TablePricingStructures`.
+
+        :param table: The database table to read the `PricingStructure` fields from.
+        :param result_set: The record in the database table containing the fields for this `PricingStructure`.
+        :param set_identifier: A callback to register the mRID of this `PricingStructure` for logging purposes.
+
+        :return: True if the `PricingStructure` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        pricing_structure = PricingStructure(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
+
+        return self._load_document(pricing_structure, table, result_set) and self._add_or_throw(pricing_structure)
+
+    def load_tariffs(self, table: TableTariffs, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `Tariff` and populate its fields from `TableTariffs`.
+
+        :param table: The database table to read the `Tariff` fields from.
+        :param result_set: The record in the database table containing the fields for this `Tariff`.
+        :param set_identifier: A callback to register the mRID of this `Tariff` for logging purposes.
+
+        :return: True if the `Tariff` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        tariff = Tariff(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
+
+        return self._load_document(tariff, table, result_set) and self._add_or_throw(tariff)
+
+    ################
+    # Associations #
+    ################
+
+    def load_customer_agreements_pricing_structures(self, table: TableCustomerAgreementsPricingStructures, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `CustomerAgreement` to `PricingStructure` association from `TableCustomerAgreementsPricingStructures`.
+
+        :param table: The database table to read the association from.
+        :param result_set: The record in the database table containing the fields for this association.
+        :param set_identifier: A callback to register the identifier of this association for logging purposes.
+
+        :return: True if the association was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        customer_agreement_mrid = set_identifier(result_set.get_string(table.customer_agreement_mrid.query_index))
+        set_identifier(f"{customer_agreement_mrid}-to-UNKNOWN")
+
+        pricing_structure_mrid = result_set.get_string(table.pricing_structure_mrid.query_index)
+        set_identifier(f"{customer_agreement_mrid}-to-{pricing_structure_mrid}")
+
+        customer_agreement = self._ensure_get(customer_agreement_mrid, CustomerAgreement)
+        pricing_structure = self._ensure_get(pricing_structure_mrid, PricingStructure)
+
+        customer_agreement.add_pricing_structure(pricing_structure)
+
+        return True
+
+    def load_pricing_structures_tariffs(self, table: TablePricingStructuresTariffs, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `PricingStructure` to `Tariff` association from `TablePricingStructuresTariffs`.
+
+        :param table: The database table to read the association from.
+        :param result_set: The record in the database table containing the fields for this association.
+        :param set_identifier: A callback to register the identifier of this association for logging purposes.
+
+        :return: True if the association was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        pricing_structure_mrid = set_identifier(result_set.get_string(table.pricing_structure_mrid.query_index))
+        set_identifier(f"{pricing_structure_mrid}-to-UNKNOWN")
+
+        tariff_mrid = result_set.get_string(table.tariff_mrid.query_index)
+
+        pricing_structure = self._ensure_get(pricing_structure_mrid, PricingStructure)
+        tariff = self._ensure_get(tariff_mrid, Tariff)
+
+        pricing_structure.add_tariff(tariff)
+
+        return True

zepben/ewb/database/sqlite/customer/customer_cim_writer.py

@@ -0,0 +1,137 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerCimWriter"]
+
+from zepben.ewb.database.sqlite.common.base_cim_writer import BaseCimWriter
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.database.sqlite.extensions.prepared_statement import PreparedStatement
+from zepben.ewb.database.sqlite.tables.associations.table_customer_agreements_pricing_structures import TableCustomerAgreementsPricingStructures
+from zepben.ewb.database.sqlite.tables.associations.table_pricing_structures_tariffs import TablePricingStructuresTariffs
+from zepben.ewb.database.sqlite.tables.iec61968.common.table_agreements import TableAgreements
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customer_agreements import TableCustomerAgreements
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customers import TableCustomers
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_pricing_structures import TablePricingStructures
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_tariffs import TableTariffs
+from zepben.ewb.model.cim.iec61968.common.agreement import Agreement
+from zepben.ewb.model.cim.iec61968.customers.customer import Customer
+from zepben.ewb.model.cim.iec61968.customers.customer_agreement import CustomerAgreement
+from zepben.ewb.model.cim.iec61968.customers.pricing_structure import PricingStructure
+from zepben.ewb.model.cim.iec61968.customers.tariff import Tariff
+
+
+class CustomerCimWriter(BaseCimWriter):
+    """
+    A class for writing the `CustomerService` tables to the database.
+
+    :param database_tables: The tables available in the database.
+    """
+
+    def __init__(self, database_tables: CustomerDatabaseTables):
+        super().__init__(database_tables)
+        self._database_tables: CustomerDatabaseTables
+
+    ###################
+    # IEC61968 Common #
+    ###################
+
+    def _save_agreement(self, table: TableAgreements, insert: PreparedStatement, agreement: Agreement, description: str) -> bool:
+        return self._save_document(table, insert, agreement, description)
+
+    ######################
+    # IEC61968 Customers #
+    ######################
+
+    def save_customer(self, customer: Customer) -> bool:
+        """
+        Save the `Customer` fields to `TableCustomers`.
+
+        :param customer: The `Customer` instance to write to the database.
+
+        :return: True if the `Customer` was successfully written to the database, otherwise False.
+        :raises SQLException: For any errors encountered writing to the database.
+        """
+        table = self._database_tables.get_table(TableCustomers)
+        insert = self._database_tables.get_insert(TableCustomers)
+
+        insert.add_value(table.kind.query_index, customer.kind.name)
+        insert.add_value(table.num_end_devices.query_index, 0)  # Currently unused
+        insert.add_value(table.special_need.query_index, customer.special_need)
+
+        return self._save_organisation_role(table, insert, customer, "customer")
+
+    def save_customer_agreement(self, customer_agreement: CustomerAgreement) -> bool:
+        """
+        Save the `CustomerAgreement` fields to `TableCustomerAgreements`.
+
+        :param customer_agreement: The `CustomerAgreement` instance to write to the database.
+
+        :return: True if the `CustomerAgreement` was successfully written to the database, otherwise False.
+        :raises SQLException: For any errors encountered writing to the database.
+        """
+        table = self._database_tables.get_table(TableCustomerAgreements)
+        insert = self._database_tables.get_insert(TableCustomerAgreements)
+
+        status = True
+        for it in customer_agreement.pricing_structures:
+            status = all([status, self._save_customer_agreement_to_pricing_structure_association(customer_agreement, it)])
+
+        insert.add_value(table.customer_mrid.query_index, self._mrid_or_none(customer_agreement.customer))
+
+        return all([status, self._save_agreement(table, insert, customer_agreement, "customer agreement")])
+
+    def save_pricing_structure(self, pricing_structure: PricingStructure) -> bool:
+        """
+        Save the `PricingStructure` fields to `TablePricingStructures`.
+
+        :param pricing_structure: The `PricingStructure` instance to write to the database.
+
+        :return: True if the `PricingStructure` was successfully written to the database, otherwise False.
+        :raises SQLException: For any errors encountered writing to the database.
+        """
+        table = self._database_tables.get_table(TablePricingStructures)
+        insert = self._database_tables.get_insert(TablePricingStructures)
+
+        status = True
+        for it in pricing_structure.tariffs:
+            status = all([status, self._save_pricing_structure_to_tariff_association(pricing_structure, it)])
+
+        return all([status, self._save_document(table, insert, pricing_structure, "pricing structure")])
+
+    def save_tariff(self, tariff: Tariff) -> bool:
+        """
+        Save the `Tariff` fields to `TableTariffs`.
+
+        :param tariff: The `Tariff` instance to write to the database.
+
+        :return: True if the `Tariff` was successfully written to the database, otherwise False.
+        :raises SQLException: For any errors encountered writing to the database.
+        """
+        table = self._database_tables.get_table(TableTariffs)
+        insert = self._database_tables.get_insert(TableTariffs)
+
+        return self._save_document(table, insert, tariff, "tariff")
+
+    ################
+    # Associations #
+    ################
+
+    def _save_customer_agreement_to_pricing_structure_association(self, customer_agreement: CustomerAgreement, pricing_structure: PricingStructure) -> bool:
+        table = self._database_tables.get_table(TableCustomerAgreementsPricingStructures)
+        insert = self._database_tables.get_insert(TableCustomerAgreementsPricingStructures)
+
+        insert.add_value(table.customer_agreement_mrid.query_index, customer_agreement.mrid)
+        insert.add_value(table.pricing_structure_mrid.query_index, pricing_structure.mrid)
+
+        return self._try_execute_single_update(insert, "customer agreement to pricing structure association")
+
+    def _save_pricing_structure_to_tariff_association(self, pricing_structure: PricingStructure, tariff: Tariff) -> bool:
+        table = self._database_tables.get_table(TablePricingStructuresTariffs)
+        insert = self._database_tables.get_insert(TablePricingStructuresTariffs)
+
+        insert.add_value(table.pricing_structure_mrid.query_index, pricing_structure.mrid)
+        insert.add_value(table.tariff_mrid.query_index, tariff.mrid)
+
+        return self._try_execute_single_update(insert, "pricing structure to tariff association")

zepben/ewb/database/sqlite/customer/customer_database_reader.py

@@ -0,0 +1,44 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerDatabaseReader"]
+
+from sqlite3 import Connection
+
+from zepben.ewb.database.sqlite.common.base_database_reader import BaseDatabaseReader
+from zepben.ewb.database.sqlite.common.metadata_collection_reader import MetadataCollectionReader
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.database.sqlite.customer.customer_service_reader import CustomerServiceReader
+from zepben.ewb.database.sqlite.tables.table_version import TableVersion
+from zepben.ewb.services.customer.customers import CustomerService
+
+class CustomerDatabaseReader(BaseDatabaseReader):
+    """
+    A class for reading the `CustomerService` objects and `MetadataCollection` from our customer database.
+
+    :param connection: The connection to the database.
+    :param service: The `CustomerService` to populate with CIM objects from the database.
+    :param database_description: The description of the database for logging (e.g. filename).
+    """
+
+    def __init__(
+        self,
+        connection: Connection,
+        service: CustomerService,
+        database_description: str,
+        tables: CustomerDatabaseTables = None,
+        metadata_reader: MetadataCollectionReader = None,
+        service_reader: CustomerServiceReader = None,
+        table_version: TableVersion = None
+    ):
+        tables = tables if tables is not None else CustomerDatabaseTables()
+        super().__init__(
+            connection,
+            metadata_reader if metadata_reader is not None else MetadataCollectionReader(service, tables, connection),
+            service_reader if service_reader is not None else CustomerServiceReader(service, tables, connection),
+            service,
+            database_description,
+            table_version if table_version is not None else TableVersion()
+        )

zepben/ewb/database/sqlite/customer/customer_database_tables.py

@@ -0,0 +1,37 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerDatabaseTables"]
+
+from typing import Generator
+
+from zepben.ewb.database.sqlite.common.base_database_tables import BaseDatabaseTables
+from zepben.ewb.database.sqlite.tables.associations.table_customer_agreements_pricing_structures import *
+from zepben.ewb.database.sqlite.tables.associations.table_pricing_structures_tariffs import *
+from zepben.ewb.database.sqlite.tables.iec61968.common.table_organisations import *
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customer_agreements import *
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customers import *
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_pricing_structures import *
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_tariffs import *
+from zepben.ewb.database.sqlite.tables.sqlite_table import *
+
+
+class CustomerDatabaseTables(BaseDatabaseTables):
+    """
+    The collection of tables for our customer databases.
+    """
+
+    @property
+    def _included_tables(self) -> Generator[SqliteTable, None, None]:
+        for table in super()._included_tables:
+            yield table
+
+        yield TableCustomerAgreements()
+        yield TableCustomerAgreementsPricingStructures()
+        yield TableCustomers()
+        yield TableOrganisations()
+        yield TablePricingStructures()
+        yield TablePricingStructuresTariffs()
+        yield TableTariffs()

zepben/ewb/database/sqlite/customer/customer_database_writer.py

@@ -0,0 +1,45 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerDatabaseWriter"]
+
+import sqlite3
+from pathlib import Path
+from sqlite3 import Connection
+from typing import Callable, Union
+
+from zepben.ewb.database.sqlite.common.base_database_writer import BaseDatabaseWriter
+from zepben.ewb.database.sqlite.common.metadata_collection_writer import MetadataCollectionWriter
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.database.sqlite.customer.customer_service_writer import CustomerServiceWriter
+from zepben.ewb.services.customer.customers import CustomerService
+
+
+class CustomerDatabaseWriter(BaseDatabaseWriter):
+    """
+    A class for writing the `CustomerService` objects and `MetadataCollection` to our customer database.
+
+    :param database_file: the filename of the database to write.
+    :param service: The `CustomerService` to save to the database.
+    """
+
+    def __init__(
+        self,
+        database_file: Union[Path, str],
+        service: CustomerService,
+        database_tables: CustomerDatabaseTables = None,
+        create_metadata_writer: Callable[[], MetadataCollectionWriter] = None,
+        create_service_writer: Callable[[], CustomerServiceWriter] = None,
+        get_connection: Callable[[str], Connection] = None
+    ):
+        database_tables = database_tables if database_tables is not None else CustomerDatabaseTables()
+
+        super().__init__(
+            database_file,
+            database_tables,
+            create_metadata_writer if create_metadata_writer is not None else lambda: MetadataCollectionWriter(service, database_tables),
+            create_service_writer if create_service_writer is not None else lambda: CustomerServiceWriter(service, database_tables),
+            get_connection if get_connection is not None else sqlite3.connect
+        )

zepben/ewb/database/sqlite/customer/customer_service_reader.py

@@ -0,0 +1,57 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerServiceReader"]
+
+from sqlite3 import Connection
+
+from zepben.ewb.database.sqlite.common.base_service_reader import BaseServiceReader
+from zepben.ewb.database.sqlite.customer.customer_cim_reader import CustomerCimReader
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.database.sqlite.tables.associations.table_customer_agreements_pricing_structures import TableCustomerAgreementsPricingStructures
+from zepben.ewb.database.sqlite.tables.associations.table_pricing_structures_tariffs import TablePricingStructuresTariffs
+from zepben.ewb.database.sqlite.tables.iec61968.common.table_organisations import TableOrganisations
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customer_agreements import TableCustomerAgreements
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customers import TableCustomers
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_pricing_structures import TablePricingStructures
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_tariffs import TableTariffs
+from zepben.ewb.services.customer.customers import CustomerService
+
+
+class CustomerServiceReader(BaseServiceReader):
+    """
+    A class for reading a [CustomerService] from the database.
+
+    @param service The [CustomerService] to populate from the database.
+    @param database_tables The tables available in the database.
+    @param connection A connection to the database.
+
+    @property reader The [CustomerCimReader] used to load the objects from the database.
+    """
+
+    def __init__(
+        self,
+        service: CustomerService,
+        database_tables: CustomerDatabaseTables,
+        connection: Connection,
+        reader: CustomerCimReader = None
+    ):
+        reader = reader if reader is not None else CustomerCimReader(service)
+        super().__init__(database_tables, connection, reader)
+
+        # This is not strictly necessary, it is just to update the type of the reader. It could be done with a generic
+        # on the base class which looks like it works, but that actually silently breaks code insight and completion
+        self._reader = reader
+
+    def _do_load(self) -> bool:
+        return all([
+            self._load_each(TableOrganisations, self._reader.load_organisations),
+            self._load_each(TableCustomers, self._reader.load_customers),
+            self._load_each(TableCustomerAgreements, self._reader.load_customer_agreements),
+            self._load_each(TablePricingStructures, self._reader.load_pricing_structures),
+            self._load_each(TableTariffs, self._reader.load_tariffs),
+            self._load_each(TableCustomerAgreementsPricingStructures, self._reader.load_customer_agreements_pricing_structures),
+            self._load_each(TablePricingStructuresTariffs, self._reader.load_pricing_structures_tariffs)
+        ])

zepben/ewb/database/sqlite/customer/customer_service_writer.py

@@ -0,0 +1,47 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerServiceWriter"]
+
+from zepben.ewb.database.sqlite.common.base_service_writer import BaseServiceWriter
+from zepben.ewb.database.sqlite.customer.customer_cim_writer import CustomerCimWriter
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.model.cim.iec61968.common.organisation import Organisation
+from zepben.ewb.model.cim.iec61968.customers.customer import Customer
+from zepben.ewb.model.cim.iec61968.customers.customer_agreement import CustomerAgreement
+from zepben.ewb.model.cim.iec61968.customers.pricing_structure import PricingStructure
+from zepben.ewb.model.cim.iec61968.customers.tariff import Tariff
+from zepben.ewb.services.customer.customers import CustomerService
+
+
+class CustomerServiceWriter(BaseServiceWriter):
+    """
+    A class for writing a `CustomerService` into the database.
+
+    :param service: The `CustomerService` to save to the database.
+    :param database_tables: The `CustomerDatabaseTables` to add to the database.
+    """
+
+    def __init__(
+        self,
+        service: CustomerService,
+        database_tables: CustomerDatabaseTables,
+        writer: CustomerCimWriter = None
+    ):
+        writer = writer if writer is not None else CustomerCimWriter(database_tables)
+        super().__init__(service, writer)
+
+        # This is not strictly necessary, it is just to update the type of the writer. It could be done with a generic
+        # on the base class which looks like it works, but that actually silently breaks code insight and completion
+        self._writer = writer
+
+    def _do_save(self) -> bool:
+        return all([
+            self._save_each_object(Organisation, self._writer.save_organisation),
+            self._save_each_object(Customer, self._writer.save_customer),
+            self._save_each_object(CustomerAgreement, self._writer.save_customer_agreement),
+            self._save_each_object(PricingStructure, self._writer.save_pricing_structure),
+            self._save_each_object(Tariff, self._writer.save_tariff)
+        ])

zepben/ewb/database/sqlite/diagram/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.

zepben/ewb/database/sqlite/diagram/diagram_cim_reader.py

@@ -0,0 +1,105 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["DiagramCimReader"]
+
+from typing import Callable
+
+from zepben.ewb.database.sqlite.common.base_cim_reader import BaseCimReader
+from zepben.ewb.database.sqlite.extensions.result_set import ResultSet
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_object_points import TableDiagramObjectPoints
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_objects import TableDiagramObjects
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagrams import TableDiagrams
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram import Diagram
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_object import DiagramObject
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_object_point import DiagramObjectPoint
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_style import DiagramStyle
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.orientation_kind import OrientationKind
+from zepben.ewb.services.diagram.diagrams import DiagramService
+
+
+class DiagramCimReader(BaseCimReader):
+    """
+    A class for reading the `DiagramService` tables from the database.
+
+    :param service: The `DiagramService` to populate from the database.
+    """
+
+    def __init__(self, service: DiagramService):
+        super().__init__(service)
+
+    ################################
+    # IEC61970 Base Diagram Layout #
+    ################################
+
+    def load_diagrams(self, table: TableDiagrams, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `Diagram` and populate its fields from `TableDiagrams`.
+
+        :param table: The database table to read the `Diagram` fields from.
+        :param result_set: The record in the database table containing the fields for this `Diagram`.
+        :param set_identifier: A callback to register the mRID of this `Diagram` for logging purposes.
+
+        :return: True if the `Diagram` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        diagram = Diagram(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
+
+        diagram.diagram_style = DiagramStyle[result_set.get_string(table.diagram_style.query_index)]
+        diagram.orientation_kind = OrientationKind[result_set.get_string(table.orientation_kind.query_index)]
+
+        return self._load_identified_object(diagram, table, result_set) and self._add_or_throw(diagram)
+
+    def load_diagram_objects(self, table: TableDiagramObjects, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `DiagramObject` and populate its fields from `TableDiagramObjects`.
+
+        :param table: The database table to read the `DiagramObject` fields from.
+        :param result_set: The record in the database table containing the fields for this `DiagramObject`.
+        :param set_identifier: A callback to register the mRID of this `DiagramObject` for logging purposes.
+
+        :return: True if the `DiagramObject` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        diagram_object = DiagramObject(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
+
+        diagram_object.diagram = self._ensure_get(
+            result_set.get_string(table.diagram_mrid.query_index, on_none=None),
+            Diagram
+        )
+        if diagram_object.diagram is not None:
+            diagram_object.diagram.add_diagram_object(diagram_object)
+
+        diagram_object.identified_object_mrid = result_set.get_string(table.identified_object_mrid.query_index, on_none=None)
+        diagram_object.style = result_set.get_string(table.style.query_index, on_none=None)
+        diagram_object.rotation = result_set.get_float(table.rotation.query_index)
+
+        return self._load_identified_object(diagram_object, table, result_set) and self._add_or_throw(diagram_object)
+
+    def load_diagram_object_points(self, table: TableDiagramObjectPoints, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `DiagramObjectPoint` and populate its fields from `TableDiagramObjectPoints`.
+
+        :param table: The database table to read the `DiagramObjectPoint` fields from.
+        :param result_set: The record in the database table containing the fields for this `DiagramObjectPoint`.
+        :param set_identifier: A callback to register the mRID of this `DiagramObjectPoint` for logging purposes.
+
+        :return: True if the `DiagramObjectPoint` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        diagram_object_mrid = set_identifier(result_set.get_string(table.diagram_object_mrid.query_index))
+        sequence_number = result_set.get_int(table.sequence_number.query_index)
+
+        set_identifier(f"{diagram_object_mrid}-point{sequence_number}")
+
+        self._service.get(diagram_object_mrid, DiagramObject).insert_point(
+            DiagramObjectPoint(
+                result_set.get_float(table.x_position.query_index),
+                result_set.get_float(table.y_position.query_index)
+            ),
+            sequence_number
+        )
+
+        return True