Das deutsche Python-Forum

Code: Alles auswählen

import math
import sqlite3
from datetime import datetime


class Abrechnung:
    """ Klasse Abrechnung. Hier befinden sich die Methoden zur Berechnung der Verbrauchsdaten"""

    def __init__(self):
        # Verbindung zur Datenbank herstellen
        verbindung = sqlite3.connect("Datenbank/verbrauch.db")
        zeiger = verbindung.cursor()

        # Datenbank Abfrage
        zeiger.execute("SELECT zaehlerstand_letzte_abrechnung FROM tarif")
        self.zaehlerstand_letzte_abrechnung = zeiger.fetchone()[0]

        zeiger.execute("SELECT arbeitspreis_netto FROM tarif")
        self.arbeitspreis = zeiger.fetchone()[0]

        zeiger.execute("SELECT grundpreis_netto FROM tarif")
        self.grundpreis_netto = zeiger.fetchone()[0]

        zeiger.execute("SELECT mehrwertsteuer FROM tarif")
        self.mehrwertsteuer = zeiger.fetchone()[0]

        zeiger.execute("SELECT Vertragsbeginn FROM Vertragsdaten")
        self.vertragsbeginn = zeiger.fetchone()[0]

        zeiger.execute("SELECT zu_zahlender_abschlag FROM tarif")
        self.zu_zahlender_abschlag = zeiger.fetchone()[0]

        verbindung.close()

        self.akt_zaehlerstand = 0
        self.arbeitspreis_netto = 0
        self.arbeitspreis_brutto = 0
        self.grundpreis_tag_brutto = 0
        self.grundpreis_tag_netto = 0
        self.gesamtbetrag_netto = 0
        self.gesamtbetrag_brutto = 0
        self.gezahlter_abschlag = 0
        self.gez_abschlag_ej = 0
        self.gp_abz_ablschlag_bj = 0
        self.gp_abz_abschlag_ej = 0

    # Abrechnungen
    # Ermittlung aktueller Zaehlerstand
    def ber_akt_zaehlerstand(self, eingabe):
        self.akt_zaehlerstand = int(eingabe) - self.zaehlerstand_letzte_abrechnung

    # Berechnung Arbeitspreis
    def ber_arbeitspreis_netto(self):
        self.arbeitspreis_netto = round(self.akt_zaehlerstand * self.arbeitspreis / 100, 2)

    def ber_arbeitspreis_brutto(self):
        self.arbeitspreis_brutto = round(
            self.akt_zaehlerstand * self.arbeitspreis / 100 * self.mehrwertsteuer, 2)

    # Berechnung Grundpreis
    def ber_grundpreis_brutto(self):
        self.grundpreis_tag_brutto = round(self.grundpreis_tag_netto * self.mehrwertsteuer, 2)
        
    ...........

Code: Alles auswählen

..............

class Verbrauchsrechner(QtWidgets.QMainWindow):
    """Main Klasse hier startet das Programm"""

    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Hauptdialog()
        self.ui.setupUi(self)
        # Slot eingerichtet
        self.ui.button_OK.clicked.connect(self.berechne)

    # Slot
    def berechne(self):
        berechnung = Abrechnung()
        berechnung.ber_akt_zaehlerstand(self.ui.spin_box_eingabe.value())
        berechnung.ber_arbeitspreis_netto()
        self.ui.arbeitspreis_netto.setText(str(berechnung.arbeitspreis_netto) + " €")
        berechnung.ber_arbeitspreis_brutto()
        self.ui.arbeitspreis_brutto.setText(str(berechnung.arbeitspreis_brutto) + " €")
        berechnung.ver_grundgebuer()
        self.ui.grundpreis_netto.setText(str(berechnung.grundpreis_tag_netto) + " €")
        berechnung.ber_grundpreis_brutto()
        self.ui.grundpreis_brutto.setText(str(berechnung.grundpreis_tag_brutto) + " €")
        berechnung.ber_gesamtbetrag_netto()
        self.ui.gesamtpreis_netto.setText(str(berechnung.gesamtbetrag_netto) + " €")
        berechnung.ber_gesamtbetrag_brutto()
        self.ui.gesamtpreis_brutto.setText(str(berechnung.gesamtbetrag_brutto) + " €")
        berechnung.er_abschlag()
        self.ui.abschlag_bis_jetzt.setText(str(berechnung.gezahlter_abschlag) + " €")
        self.ui.abschlag_ende_des_jahres.setText(str(berechnung.gez_abschlag_ej) + " €")
        berechnung.ber_gp_abz_abschlag_bj()
        self.ui.gp_abz_abschlag_bj.setText(str(berechnung.gp_abz_ablschlag_bj) + " €")
        berechnung.ber_gp_abz_abschlag_ej()
        self.ui.gp_abz_abschlag_ej.setText(str(berechnung.gp_abz_abschlag_ej) + " €")

...................

Code: Alles auswählen

DATABASE_NAME = "Datenbank/verbrauch.db"

class Abrechnung:
    """ Klasse Abrechnung. Hier befinden sich die Methoden zur Berechnung der Verbrauchsdaten"""

    def __init__(self, zaehlerstand_letzte_abrechnung, arbeitspreis_netto, grundpreis_netto, mehrwertsteuer, zu_zahlender_abschlag, Vertragsbeginn, aktueller_zaehlerstand):
        self.zaehlerstand_letzte_abrechnung = zaehlerstand_letzte_abrechnung
        self.arbeitspreis_netto = arbeitspreis_netto
        self.grundpreis_netto = grundpreis_netto
        self.mehrwertsteuer = mehrwertsteuer
        self.zu_zahlender_abschlag = zu_zahlender_abschlag
        self.vertragsbeginn = vertragsbeginn
        self.aktueller_zaehlerstand = aktueller_zaehlerstand

    @classmethod
    def from_database(cls, database, aktueller_zaehlerstand):
        with closing(database.cursor()) as cursor:
            cursor.execute("SELECT zaehlerstand_letzte_abrechnung, arbeitspreis_netto, grundpreis_netto, mehrwertsteuer, zu_zahlender_abschlag, Vertragsbeginn FROM tarif, Vertragsdaten WHERE Vertragsdaten.tarif_id = tarif.id AND bedingung_fuer_aktuellen_vertrag")
            zaehlerstand_letzte_abrechnung, arbeitspreis_netto, grundpreis_netto, mehrwertsteuer, zu_zahlender_abschlag, Vertragsbeginn = cursor.fetchone()
        return cls(zaehlerstand_letzte_abrechnung, arbeitspreis_netto, grundpreis_netto, mehrwertsteuer, zu_zahlender_abschlag, Vertragsbeginn, aktueller_zaehlerstand)

    @property
    def arbeitspreis_netto(self):
        return self.akt_zaehlerstand * self.arbeitspreis / 100

    @property
    def arbeitspreis_brutto(self):
        return self.arbeitspreis_netto * self.mehrwertsteuer

...

    def berechne(self):
        zaehlerstand = self.ui.spin_box_eingabe.value()
        with closing(sqlite3.connect(DATABASE_NAME)) as database:
            abrechnung = Abrechnung.from_database(database, zaehlerstand)
        self.ui.arbeitspreis_netto.setText(f"{abrechnung.arbeitspreis_netto:.2f} €")
        self.ui.arbeitspreis_brutto.setText(f"{abrechnung.arbeitspreis_brutto:.2f} €")
        ...

Code: Alles auswählen

from contextlib import closing
from datetime import date as Date

# in der Standardbibliothek gibt es einige Module,
# die sich nicht an die Namensgebungskonventionen halten.
# Macht aber nichts, kann man umbenennen
# date ist eine Klasse, also der erste Buchstabe Groß
from dataclasses import dataclass

# oftmals die einfachere Möglichkeit, vor allem dann, wenn
# man sehr viele Argumente für die Initialisierung der Instanz übergeben muss

@dataclass
class Abrechnung:
    """Klasse Abrechnung. Hier befinden sich die Methoden zur Berechnung der Verbrauchsdaten"""

    zaehlerstand_letzte_abrechnung: int
    grundpreis_netto: float
    mehrwertsteuer: float
    zu_zahlender_abschlag: int
    vertragsbeginn: Date
    aktueller_zaehlerstand: int

    @classmethod
    def from_database(cls, database, aktueller_zaehlerstand):
        with closing(database.cursor()) as cursor:
            # https://www.freeformatter.com/sql-formatter.html
            cursor.execute(
                """
                SELECT
                    zaehlerstand_letzte_abrechnung,
                    arbeitspreis_netto,
                    grundpreis_netto,
                    mehrwertsteuer,
                    zu_zahlender_abschlag,
                    vertragsbeginn 
                FROM
                    tarif,
                    vertragsdaten 
                WHERE
                    vertragsdaten.tarif_id = tarif.id 
                    AND bedingung_fuer_aktuellen_vertrag
                """
            )
            return cls(*cursor.fetchone())

    @property
    def arbeitspreis_netto(self):
        return self.aktueller_zaehlerstand * self.arbeitspreis / 100

    @property
    def arbeitspreis_brutto(self):
        return self.arbeitspreis_netto * self.mehrwertsteuer


def berechne(self):
    zaehlerstand = self.ui.spin_box_eingabe.value()

    with closing(sqlite3.connect(DATABASE_NAME)) as database:
        abrechnung = Abrechnung.from_database(database, zaehlerstand)

    self.ui.arbeitspreis_netto.setText(f"{abrechnung.arbeitspreis_netto:.2f} €")
    self.ui.arbeitspreis_brutto.setText(f"{abrechnung.arbeitspreis_brutto:.2f} €")
    ...

Code: Alles auswählen

from sqlalchemy import create_engine
from sqlalchemy.orm import Session


DATABASE_NAME = "Datenbank/testdatenbank.db"

engine = create_engine(DATABASE_NAME)
conn = engine.connect()



class Abrechnung:
    """ Klasse Abrechnung. Hier befinden sich die Methoden zur Berechnung der Verbrauchsdaten"""


    def from_database(self):
        with Session(engine) as session:
            person = session.get(Person, 1)
            print(person)

Code: Alles auswählen

from sqlalchemy import Column
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import relationship

Base = declarative_base()

class User(Base):
    __tablename__ = "user_account"
    id = Column(Integer, primary_key=True)
    name = Column(String(30))
    fullname = Column(String)
    addresses = relationship(
        "Address", back_populates="user", cascade="all, delete-orphan"
    )
    def __repr__(self):
        return f"User(id={self.id!r}, name={self.name!r}, fullname={self.fullname!r})"

class Address(Base):
    __tablename__ = "address"
    id = Column(Integer, primary_key=True)
    email_address = Column(String, nullable=False)
    user_id = Column(Integer, ForeignKey("user_account.id"), nullable=False)
    user = relationship("User", back_populates="addresses")
    def __repr__(self):
        return f"Address(id={self.id!r}, email_address={self.email_address!r})"

Code: Alles auswählen

from sqlalchemy.orm import Session

with Session(engine) as session:
    spongebob = User(
        name="spongebob",
        fullname="Spongebob Squarepants",
        addresses=[Address(email_address="spongebob@sqlalchemy.org")],
    )
    sandy = User(
        name="sandy",
        fullname="Sandy Cheeks",
        addresses=[
            Address(email_address="sandy@sqlalchemy.org"),
            Address(email_address="sandy@squirrelpower.org"),
        ],
    )
    patrick = User(name="patrick", fullname="Patrick Star")
    session.add_all([spongebob, sandy, patrick])
    session.commit()

Code: Alles auswählen

from sqlalchemy import select

session = Session(engine)

stmt = select(User).where(User.name.in_(["spongebob", "sandy"]))

for user in session.scalars(stmt):
    print(user)

Code: Alles auswählen

from sqlalchemy import create_engine, Column
from sqlalchemy.orm import declarative_base
from sqlalchemy.sql.sqltypes import Integer, Float

engine = create_engine('sqlite:///Datenbank/verbrauch.db')
base = declarative_base()
conn = engine.connect()


class Tarif(base):
    __tablename__ = 'tarif'

    tarif_id = Column(Integer, primary_key=True, autoincrement=True)
    arbeitspreis = Column(Float, nullable=False)
    grundpreis = Column(Float, nullable=False)
    mehrwertsteuer = Column(Float, nullable=False)
    zaehlerstand_letzte_abrechnung = Column(Float, nullable=False)
    zu_zahlender_abschlag = Column(Integer, nullable=False)

    def __init__(self, arbeitspreis: float, grundpreis: float, mehrwertsteuer: float,
                 zaehlerstand_letzte_abrechnung: float, zu_zahlender_abschlag: float):
        self.arbeitspreis = arbeitspreis
        self.grundpreis = grundpreis
        self.mehrwertsteuer = mehrwertsteuer
        self.zaehlerstand_letzte_abrechnung = zaehlerstand_letzte_abrechnung
        self.zu_zahlender_abschlag = zu_zahlender_abschlag


base.metadata.create_all(conn)

Code: Alles auswählen

from sqlalchemy.orm import Session
from Datenbankverbindung import Tarif, engine


class Abrechnung:
    """ Klasse Abrechnung. Hier befinden sich die Methoden zur Berechnung der Verbrauchsdaten"""

    def __init__(self, arbeitspreis, grundpreis, mehrwertsteuer):
        self.arbeitspreis = arbeitspreis
        self.grundpreis = grundpreis
        self.mehrwertsteuer = mehrwertsteuer

    @classmethod
    def from_database(cls, eingegebener_zaehlerstand):
        my_session = Session(bind=engine)
        tarif = my_session.get(Tarif, 1)
        return cls(tarif.arbeitspreis,
                   tarif.grundpreis, tarif.mehrwertsteuer)