Interaktion zweier Nutzer

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
Benutzeravatar
Kebap
User
Beiträge: 776
Registriert: Dienstag 15. November 2011, 14:20
Wohnort: Dortmund

Hallo,

ich arbeite an einer Idee, die später als Webanwendung realisiert werden soll. Der erste Prototyp ohne GUI, um die Logik zu testen. Dabei trete ich aber schon früh auf der Stelle.

Es sollen zwei Nutzer miteinander in eine längerfristige Interaktion treten können. Diese besteht darin, dass sie füreinander Einkäufe erledigen, Geld leihen und später zurückzahlen, usw. Es soll darüber Übersicht behalten werden, und auch wer wem aktuell wie viel schuldet. Beide Nutzer sollen Einträge anlegen können, die das Gegenüber bestätigen muss. Eine Übersichtsseite zeigt alle Einträge der Interaktion und die aktuellen Summen. Nachrichten sollen ausgetauscht werden, falls bestimmte Ereignisse eintreten, bspw. Betrag X oder Zeitraum Y überschritten wurde (noch genauer zu definieren)

Ich habe folgende Klassen vorgesehen: Nutzer, Interaktion, Eintrag, Nachricht

Nun strauchle ich schon kurz nach dem Anlegen der Nutzer, wenn es darum geht, welche Datenstruktur empfehlenswert sein könnte, um die Interaktionen der Nutzer untereinander darzustellen, und welche Klasse welche Daten bereithalten soll. Aktuelles Beispiel: Ein Nutzer lädt den anderen ein, einer neuen Interaktion teilzunehmen. Welche Daten behält der Nutzer, welche die Interaktion? Brauche ich vielleicht weitere Klassen?

Das wird nicht leichter dadurch, dass ich die Klassen so schneiden will, dass sie später auch per Web benutzt werden können. Dann natürlich mit Login, usw. Aber dort soll ein User alle Informationen in Formulare eintragen können und im Hintergrund wird die gleiche Logik angesteuert.

Freu mich auf eure Kommentare!

Code: Alles auswählen

from datetime import date

class Entry(object):
    def __init__(self, title, amount = 0, description = "", timestamp = None):
        self.title = title
        self.amount = amount
        self.description = description
        self.timestamp = timestamp

class Note(object):    
    def __init__(self, sender, receiver, timestamp, head, body):
        self.sender = sender
        self.receiver = receiver
        self.timestamp = timestamp
        self.head = head
        self.body = body

class User(object):
    users = 0

    def __init__(self, name, chips = 0, passwd = "", mail = ""):
        self.name = name
        self.chips = chips
        self.passwd = passwd
        self.mail = mail
        self.interactions = {}
        
        User.users += 1
        self.number = User.users
        
    def show(self):
        show_me = "#{} User {} has {} chips".format(self.number, self.name, self.chips)
        if self.passwd != "":
            show_me += "and a password"
        if self.mail != "":
            show_me += "and a mail"
        show_me += "."
        return show_me
        
    def receive_message(self, message):
        pass        

    def interact_with(self, opponent):
        new_interaction = Interaction(self, opponent)
        self.interactions[opponent.number] = new_interaction
    
    def accept_interaction(self, opponent):
        pass
    
    def extend_interaction(self, opponent, entry):
        pass
    
    def show_interaction(self, opponent):
        pass
    
class Interaction(object):    
    def __init__(self, founder, invited, name = ""):
        self.founder = founder
        self.invited = invited
        self.name = name
        
    def show(self):
        pass

def main():
    pass

def test():
    r = User("Robert", 10)
    print r.show()
    m = User("Maria", 10)
    print m.show()
    
    r.interact_with(m)
    m.accept_interaction(r)
    
    e = Entry("Einkauf", 3.99, "Brot, Wasser", date(2018, 03, 17))
    r.extend_interaction(m, e)
    print r.show_interaction(m)
    
    e2 = Entry("Zahlung", 3.99, "für Einkauf", date(2018, 03, 23))
    m.extend_interaction(r, e2)
    print m.show_interaction(r)

if __name__ == "__main__":
    # main()
    test()
MorgenGrauen: 1 Welt, 8 Rassen, 13 Gilden, >250 Abenteuer, >5000 Waffen & Rüstungen,
>7000 NPC, >16000 Räume, >200 freiwillige Programmierer, nur Text, viel Spaß, seit 1992.
Sirius3
User
Beiträge: 18266
Registriert: Sonntag 21. Oktober 2012, 17:20

@Kebap: Du mußt Dir als erstes überlegen, welche Interaktionen möglich sein sollen. Die Klassen setzt Du am besten gleich via ORM (SQLAlchemy) um, da sie eher früher als später in eine Datenbank wandern werden. Ansonsten ist Dein Model noch ziemlich mager. Was ist ein Entry? Was soll eine Interaction sein? Wenn man eine Interaction erweitern kann, warum ist das eine Methode des Users? Wo ist die Referenz der Entries in den Interactions? Geht das in Richtung Buchführung? Hast Du eigentlich Konten mit Saldo?

Daten werden immer als DateTime mit Zeitzone gespeichert. Alles andere macht früher oder später Probleme. Da Du Bestätigungen haben willst, ist wohl ein wichtiger Datensatz die Bestätigung. Diese sollte die kryptographische Signatur der Nachricht enthalten. Du brauchst also auch noch für jeden Nutzer deren öffentlichen Schlüssel. Die privaten Schlüssel sollten alle Nutzer nur bei sich gespeichert haben.

Gibt es auch noch Interaktionen mit mehr als zwei Beteiligten? Parameter sollten nur Default-Werte haben, wenn dies auch sinnvoll ist. Ein Entry ohne timestamp, eine Interaktion ohne Namen? Um das Gleichheitszeichen der Defaultwerte macht man keine Leerzeichen.
Benutzeravatar
kbr
User
Beiträge: 1507
Registriert: Mittwoch 15. Oktober 2008, 09:27

@Kebap: auch mich irritieren die vielen Interaktions-Methoden am Nutzer. Weiter ist mir nicht klar, was einen Eintrag von einer Nachricht unterscheidet. Vielleicht möchtest Du für den Entwurf ein ER-Diagramm zur Hilfe nehmen. Auch im "digitalen Zeitalter" eignen sich dafür Papier, Bleistift, Radiergummi sowie eine Tasse Kaffee vorzüglich.
Benutzeravatar
Kebap
User
Beiträge: 776
Registriert: Dienstag 15. November 2011, 14:20
Wohnort: Dortmund

Das waren viele Fragen und Anregungen, danke dafür. Ich versuche alle zu beantworten.

Interaktion ist ein schwieriger Begriff. Ich meine nicht das, was ein Nutzer mit dem Programm macht. Ich meine die Beziehung zwischen zwei Nutzern. Letztendlich geht es tatsächlich in Richtung Buchführung, Konten mit Saldo klingt treffend.

Ein Entry ist dann ein Eintrag im Konto, mit Wert und Namen, ggf. weiteren Details. Hingegen eine Interaction ist die komplette Beziehung zwischen zwei Nutzern, also inkl. des Konto. Die Referenz der Entries in den Interactions hatte ich noch vergessen, muss natürlich folgen. ORM macht Sinn, muss ich prüfen, werde ich dann dort einbauen.

Viele Methoden habe ich dem Nutzer hinzugefügt, weil er ja später im Web aktiv ist und einen Eintrag anlegt, eine Übersicht prüft, usw. Vermutlich ist das nicht richtig. Es macht nur einen Unterschied, ob Nutzer 1 oder 2 einen Eintrag anlegt. Ich wusste spontan nicht, wie ich das besser trennen kann, so dass es doch testbar bleibt, solange noch keine Weboberfläche existiert.

Die Bestätigungen brauchen aus meiner Sicht keine Signaturen oder Kryptographie. Es soll so laufen: Nutzer 1 erstellt einen Eintrag. Dieser hat automatisch Status: unbestätigt. Nutzer 2 erhält dazu eine Nachricht. Er loggt sich selbst ein, prüft den Eintrag und akzeptiert. Dadurch wird der Status: bestätigt. Mehr ist das nicht. Das ist auch der Unterschied zwischen Eintrag (im Konto) und Nachricht (zur Info an Nutzer)

Ich hatte tatsächlich ein kleines ER-Diagramm auf Papier erstellt, bevor ich zur Umsetzung kam. Stelle aber fest, dass mir noch viele Lücken unterlaufen sind und ich Sachen ändern muss, sobald der Code zu laufen beginnt. Hier bin ich nicht sattelfest. Hängt vielleicht auch damit zusammen, dass Methoden am Nutzer eigentlich zur Interaction gehören, osä. Da brauche ich noch Aufklärung.

Ob es Interaktionen mit mehr als zwei Nutzern geben kann oder soll, habe ich mich auch gefragt. Bin spontan nicht sicher, wie das logisch aussehen würde. Generell spricht nichts dagegen, würde ich aber erstmal zurückstellen, bis die grundlegenden Baustellen wie ORM, Weboberfläche, usw. klarer sind.

Die Stichworte Buchführung / Konten brachten mich auch auf die Idee, die Eigenprogrammierung sein zu lassen, und dies als online Tabellenkalkulation aufzusetzen. Einerseits würde das sicherlich Zeit sparen. Andererseits möchte ich nicht alle Daten an den großen Bruder geben. Gibt es Python Entwicklungen in die Richtung, die ich auf eigenen Server laufen lassen kann? Dritterseits fehlt auch Funktionsumfang, oder müsste dann erweitert werden, bspw. Benachrichtigungen und Bestätigungen, Kommentarfelder, usw. Das spricht auch für eine selbst gehostete Anwendung.
MorgenGrauen: 1 Welt, 8 Rassen, 13 Gilden, >250 Abenteuer, >5000 Waffen & Rüstungen,
>7000 NPC, >16000 Räume, >200 freiwillige Programmierer, nur Text, viel Spaß, seit 1992.
Antworten