zepben.ewb 1.0.0b1__py3-none-any.whl

zepben/ewb/database/sqlite/common/base_service_reader.py

@@ -0,0 +1,50 @@
+#  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__ = ["BaseServiceReader"]
+
+from abc import ABC, abstractmethod
+from sqlite3 import Connection
+
+from zepben.ewb.database.sqlite.common.base_cim_reader import BaseCimReader
+from zepben.ewb.database.sqlite.common.base_collection_reader import BaseCollectionReader
+from zepben.ewb.database.sqlite.common.base_database_tables import BaseDatabaseTables
+from zepben.ewb.database.sqlite.tables.iec61970.base.core.table_name_types import TableNameTypes
+from zepben.ewb.database.sqlite.tables.iec61970.base.core.table_names import TableNames
+
+
+class BaseServiceReader(BaseCollectionReader, ABC):
+    """
+    A base class for reading items stored in a `BaseService` from the database.
+
+    :param tables: The tables available in the database.
+    :param connection: A connection to the database.
+    :param reader: The `BaseCimReader` used to load the objects from the database.
+    """
+
+    def __init__(
+        self,
+        tables: BaseDatabaseTables,
+        connection: Connection,
+        reader: BaseCimReader
+    ):
+        super().__init__(tables, connection)
+        self._reader: BaseCimReader = reader
+        """
+        The `BaseCimReader` used to load the objects from the database.
+        """
+
+    def load(self) -> bool:
+        return (self._do_load()
+                and self._load_each(TableNameTypes, self._reader.load_name_types)
+                and self._load_each(TableNames, self._reader.load_names))
+
+    @abstractmethod
+    def _do_load(self) -> bool:
+        """
+        Load the service specific objects from the database.
+
+        :return: True if the objects were successfully loaded from the database, otherwise False
+        """

zepben/ewb/database/sqlite/common/base_service_writer.py

@@ -0,0 +1,104 @@
+#  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__ = ["BaseServiceWriter"]
+
+from abc import ABC, abstractmethod
+from typing import Callable, Type
+
+from zepben.ewb.database.sqlite.common.base_cim_writer import BaseCimWriter
+from zepben.ewb.database.sqlite.common.base_collection_writer import BaseCollectionWriter
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import TIdentifiedObject
+from zepben.ewb.model.cim.iec61970.base.core.name import Name
+from zepben.ewb.model.cim.iec61970.base.core.name_type import NameType
+from zepben.ewb.services.common.base_service import BaseService
+
+
+class BaseServiceWriter(BaseCollectionWriter, ABC):
+    """
+    A base class for writing object from a [BaseService] into the database.
+
+    :param service: The `BaseService` to save to the database.
+    :param writer: The `BaseServiceWriter` used to actually write the objects to the database.
+    """
+
+    def __init__(self, service: BaseService, writer: BaseCimWriter):
+        super().__init__()
+        self._service: BaseService = service
+        """
+        The `BaseService` to save to the database.
+        """
+
+        self._writer: BaseCimWriter = writer
+        """
+        The `BaseServiceWriter` used to actually write the objects to the database.
+        """
+
+    def save(self) -> bool:
+        return all([self._save_name_types(), self._do_save()])
+
+    @abstractmethod
+    def _do_save(self) -> bool:
+        """
+        Save the service specific objects to the database.
+
+        :return: True if the objects were successfully saved to the database, otherwise False
+        """
+
+    """
+    Save each object of the specified type using the provided `saver`.
+    
+    @param T The type of object to save to the database.
+    @param saver The callback used to save the objects to the database. Will be called once for each object and should return True if the object is
+      successfully saved to the database.
+    
+    :return: True if all objects are successfully saved to the database, otherwise False.
+    """
+
+    def _save_each_object(self, type_: Type[TIdentifiedObject], saver: Callable[[TIdentifiedObject], bool]) -> bool:
+        status = True
+        for it in self._service.objects(type_):
+            status = status and self._validate_save_object(it, saver)
+
+        return status
+
+    """
+    Validate that an object is actually saved to the database, logging an error if anything goes wrong.
+    
+    @param T The type of object being saved.
+    @param it The object being saved.
+    @param saver The callback actually saving the object to the database.
+    
+    :return: True if the object is successfully saved to the database, otherwise False.
+    """
+
+    def _validate_save_object(self, it: TIdentifiedObject, saver: Callable[[TIdentifiedObject], bool]) -> bool:
+        def log_error(e: Exception):
+            self._logger.error(f"Failed to save {it.__class__.__name__} {it.name} [{it.mrid}]: {e}")
+
+        return self._validate_save(it, saver, log_error)
+
+    def _save_name_types(self) -> bool:
+        status = True
+
+        for it in self._service.name_types:
+            status = all([status, self._validate_save_name_type(it, self._writer.save_name_type)])
+
+            for name in it.names:
+                status = all([status, self._validate_save_name(name, self._writer.save_name)])
+
+        return status
+
+    def _validate_save_name_type(self, name_type: NameType, saver: Callable[[NameType], bool]) -> bool:
+        def log_error(e: Exception):
+            self._logger.error(f"Failed to save {name_type.__class__.__name__} {name_type.name}: {e}")
+
+        return self._validate_save(name_type, saver, log_error)
+
+    def _validate_save_name(self, name: Name, saver: Callable[[Name], bool]) -> bool:
+        def log_error(e: Exception):
+            self._logger.error(f"Failed to save {name.__class__.__name__} {name.name}: {e}")
+
+        return self._validate_save(name, saver, log_error)

zepben/ewb/database/sqlite/common/metadata_collection_reader.py

@@ -0,0 +1,39 @@
+#  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__ = ["MetadataCollectionReader"]
+
+from sqlite3 import Connection
+
+from zepben.ewb.database.sqlite.common.base_collection_reader import BaseCollectionReader
+from zepben.ewb.database.sqlite.common.base_database_tables import BaseDatabaseTables
+from zepben.ewb.database.sqlite.common.metadata_entry_reader import MetadataEntryReader
+from zepben.ewb.database.sqlite.tables.table_metadata_data_sources import TableMetadataDataSources
+from zepben.ewb.services.common.base_service import BaseService
+
+
+class MetadataCollectionReader(BaseCollectionReader):
+    """
+    Class for reading the `MetadataCollection` from the database.
+
+    :param service: The `BaseService` containing the `MetadataCollection` to populate from the database.
+    :param tables: The tables available in the database.
+    :param connection: The `Connection` to the database.
+    """
+
+    def __init__(
+        self,
+        service: BaseService,
+        tables: BaseDatabaseTables,
+        connection: Connection,
+        reader: MetadataEntryReader = None
+    ):
+        super().__init__(tables, connection)
+        self._reader: MetadataEntryReader = reader if reader is not None else MetadataEntryReader(service)
+
+    def load(self) -> bool:
+        return all([
+            self._load_each(TableMetadataDataSources, self._reader.load_metadata)
+        ])

zepben/ewb/database/sqlite/common/metadata_collection_writer.py

@@ -0,0 +1,38 @@
+#  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__ = ["MetadataCollectionWriter"]
+
+from zepben.ewb.database.sqlite.common.base_collection_writer import BaseCollectionWriter
+from zepben.ewb.database.sqlite.common.base_database_tables import BaseDatabaseTables
+from zepben.ewb.database.sqlite.common.metadata_entry_writer import MetadataEntryWriter
+from zepben.ewb.services.common.base_service import BaseService
+from zepben.ewb.services.common.meta.data_source import DataSource
+
+
+class MetadataCollectionWriter(BaseCollectionWriter):
+    """
+    Class for writing the `MetadataCollection` to the database.
+
+    :param service: The `BaseService` containing the `MetadataCollection` to save to the database.
+    :param database_tables: The tables available in the database.
+    """
+
+    def __init__(
+        self,
+        service: BaseService,
+        database_tables: BaseDatabaseTables,
+        writer: MetadataEntryWriter = None
+    ):
+        super().__init__()
+        self._service: BaseService = service
+        self._writer: MetadataEntryWriter = writer if writer is not None else MetadataEntryWriter(database_tables)
+
+
+    def save(self) -> bool:
+        def log_error(it: DataSource, e: Exception):
+            self._logger.error(f"Failed to save {it}: {e}")
+
+        return self._save_each(self._service.metadata.data_sources, self._writer.save_data_source, log_error)

zepben/ewb/database/sqlite/common/metadata_entry_reader.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__ = ["MetadataEntryReader"]
+
+import datetime
+from typing import Callable
+
+from zepben.ewb.database.sqlite.extensions.result_set import ResultSet
+from zepben.ewb.database.sqlite.tables.table_metadata_data_sources import TableMetadataDataSources
+from zepben.ewb.services.common.base_service import BaseService
+from zepben.ewb.services.common.meta.data_source import DataSource
+
+
+class MetadataEntryReader:
+    """
+    A class for reading the `MetadataCollection` entries from the database.
+
+    :param service: The `BaseService` containing the `MetadataCollection` to populate from the database.
+    """
+
+    def __init__(self, service: BaseService):
+        super().__init__()
+        self._service: BaseService = service
+
+    def load_metadata(self, table: TableMetadataDataSources, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Populate the `DataSource` fields from `TableMetadataDataSources`.
+    
+        :param table: The database table to read the `DataSource` fields from.
+        :param result_set: The record in the database table containing the fields for this `DataSource`.
+        :param set_identifier: A callback to set the identifier of the current row for logging purposes, which returns a copy of the provided string for
+          fluent use.
+    
+        :return: True if the `DataSource` is successfully loaded from the database, otherwise False.
+        """
+        data_source = DataSource(
+            set_identifier(result_set.get_string(table.source.query_index)),
+            result_set.get_string(table.version.query_index),
+            result_set.get_instant(table.timestamp.query_index, datetime.datetime(1970, 1, 1))
+        )
+
+        return self._service.metadata.add(data_source)

zepben/ewb/database/sqlite/common/metadata_entry_writer.py

@@ -0,0 +1,41 @@
+#  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__ = ["MetadataEntryWriter"]
+
+from zepben.ewb.database.sqlite.common.base_database_tables import BaseDatabaseTables
+from zepben.ewb.database.sqlite.common.base_entry_writer import BaseEntryWriter
+from zepben.ewb.database.sqlite.tables.table_metadata_data_sources import TableMetadataDataSources
+from zepben.ewb.services.common.meta.data_source import DataSource
+
+class MetadataEntryWriter(BaseEntryWriter):
+    """
+    A class for reading the `MetadataCollection` entries from the database.
+
+    @param database_tables The tables that are available in the database.
+    """
+
+    def __init__(self, database_tables: BaseDatabaseTables):
+        super().__init__()
+        self._database_tables: BaseDatabaseTables = database_tables
+
+
+    def save_data_source(self, data_source: DataSource) -> bool:
+        """
+        Save the `DataSource` fields to `TableMetadataDataSources`.
+
+        @param data_source The `DataSource` to save to the database.
+
+        @return true if the `DataSource` is successfully written to the database, otherwise false.
+        """
+        table = self._database_tables.get_table(TableMetadataDataSources)
+        insert = self._database_tables.get_insert(TableMetadataDataSources)
+
+        insert.add_value(table.source.query_index, data_source.source)
+        insert.add_value(table.version.query_index, data_source.version)
+        # The timestamp in the database uses Z for UTC while python uses +HH:mm format, so convert between them.
+        insert.add_value(table.timestamp.query_index, f"{data_source.timestamp.isoformat()}Z")
+
+        return insert.try_execute_single_update(lambda ex: insert.log_failure(self._logger, "data source", ex))

zepben/ewb/database/sqlite/common/reader_exceptions.py

@@ -0,0 +1,30 @@
+#  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__ = ["MRIDLookupException", "NameTypeLookupException", "DuplicateMRIDException", "DuplicateNameTypeException"]
+
+
+class MRIDLookupException(Exception):
+    """
+    An exception indicating that an mRID could not be found in a [BaseService].
+    """
+
+
+class NameTypeLookupException(Exception):
+    """
+    An exception indicating that a [NameType] could not be found in a [BaseService].
+    """
+
+
+class DuplicateMRIDException(Exception):
+    """
+    An exception indicating that an mRID has already been used by a different objects in a [BaseService].
+    """
+
+
+class DuplicateNameTypeException(Exception):
+    """
+    An exception indicating that n [NameType] has already been used in a [BaseService].
+    """

zepben/ewb/database/sqlite/customer/__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/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")