예제 #1
0
    def post(self):
        """Anlegen eines neuen Rating-Objekts.

        **ACHTUNG:** Wir fassen die vom Client gesendeten Daten als Vorschlag auf.
        So ist zum Beispiel die Vergabe der ID nicht Aufgabe des Clients.
        Selbst wenn der Client eine ID in dem Proposal vergeben sollte, so
        liegt es an der BankAdministration (Businesslogik), eine korrekte ID
        zu vergeben. *Das korrigierte Objekt wird schließlich zurückgegeben.*
        """
        adm = ProjectAdministration()

        rat = Rating.from_dict(api.payload)
        """RATSCHLAG: Prüfen Sie stets die Referenzen auf valide Werte, bevor Sie diese verwenden!"""
        if rat is not None:
            """ Wir verwenden id, evaluator, to_be_assessed, passed, grade des Proposals für die Erzeugung
            eines Customer-Objekts. Das serverseitig erzeugte Objekt ist das maßgebliche und 
            wird auch dem Client zurückgegeben. 
            """
            r = adm.create_rating(rat.get_creation_time(), rat.get_project(),
                                  rat.get_evaluator(),
                                  rat.get_to_be_assessed(), rat.get_grade(),
                                  rat.get_passed())
            return r, 200
        else:
            # Wenn irgendetwas schiefgeht, dann geben wir nichts zurück und werfen einen Server-Fehler.
            return '', 500
예제 #2
0
    def put(self, id):
        """Update eines bestimmten Rating-Objekts.
        """
        adm = ProjectAdministration()
        ra = Rating.from_dict(api.payload)

        if ra is not None:
            ra.set_id(id)
            adm.save_rating(ra)
            return '', 200
        else:
            return '', 500
    def find_by_id(self, id):
        """Suchen eines Ratings mit vorgegebener ID. Da diese eindeutig ist,
        wird genau ein Objekt zurückgegeben.

        :param id Primärschlüsselattribut (->DB)
        :return ID Objekt, das dem übergebenen Schlüssel entspricht, None bei
            nicht vorhandenem DB-Tupel.
        """
        result = []

        cursor = self._cnx.cursor()
        command = "SELECT id,creation_time, project, evaluator, to_be_assessed, grade, passed FROM rating WHERE id={}".format(id)
        cursor.execute(command)
        tuples = cursor.fetchall()

        if tuples[0] is not None:
            (id,creation_time, project, evaluator, to_be_assessed, grade, passed) = tuples[0]
            rating = Rating()
            rating.set_id(id)
            rating.set_creation_time(creation_time)
            rating.set_project(project)
            rating.set_evaluator(evaluator)
            rating.set_to_be_assessed(to_be_assessed)
            rating.set_grade(grade)
            rating.set_passed(passed)
            result.append(rating)

        self._cnx.commit()
        cursor.close()

        return result
    def find_all(self):

        result = []
        cursor = self._cnx.cursor()
        cursor.execute("SELECT id, creation_time, project, evaluator, to_be_assessed, grade, passed  from rating")
        tuples = cursor.fetchall()

        for (id, creation_time, project, evaluator, to_be_assessed, grade, passed) in tuples:
            rating = Rating()
            rating.set_id(id)
            rating.set_creation_time(creation_time)
            rating.set_project(project)
            rating.set_evaluator(evaluator)
            rating.set_to_be_assessed(to_be_assessed)
            rating.set_grade(grade)
            rating.set_passed(passed)
            result.append(rating)

        self._cnx.commit()
        cursor.close()

        return result
    def find_by_project(self, project):
        """Ausleseen einer role_id einer Person.

        :param owner_id Schlüssel des zugehörigen Person.
        :return Eine Sammlung mit Rating-Objekten, die sämtliche Role_IDs der
                betreffenden Person  repräsentieren.
        """
        result = []
        cursor = self._cnx.cursor()
        command = "SELECT id, creation_time, project, evaluator, to_be_assessed, grade, passed FROM rating WHERE project={} ORDER BY id".format(project)
        cursor.execute(command)
        tuples = cursor.fetchall()

        for (id, creation_time, project, evaluator, to_be_assessed, grade, passed) in tuples:
            rating = Rating()
            rating.set_id(id)
            rating.set_creation_time(creation_time)
            rating.set_project(project)
            rating.set_evaluator(evaluator)
            rating.set_to_be_assessed(to_be_assessed)
            rating.set_grade(grade)
            rating.set_passed(passed)
            result.append(rating)

        self._cnx.commit()
        cursor.close()

        return result
    def find_rating_by_to_be_assessed(self, to_be_assessed):

        result = []

        cursor = self._cnx.cursor()
        command = "SELECT id,creation_time, project, evaluator, to_be_assessed, grade, passed FROM rating WHERE to_be_assessed='{}'".format(to_be_assessed)
        cursor.execute(command)
        tuples = cursor.fetchall()

        for (id, creation_time, project, evaluator, to_be_assessed, grade, passed) in tuples:
            rating = Rating()
            rating.set_id(id)
            rating.set_creation_time(creation_time)
            rating.set_project(project)
            rating.set_evaluator(evaluator)
            rating.set_to_be_assessed(to_be_assessed)
            rating.set_grade(grade)
            rating.set_passed(passed)
            result.append(rating)

        self._cnx.commit()
        cursor.close()

        return result
            rating.set_grade(grade)
            rating.set_passed(passed)
            result.append(rating)

        self._cnx.commit()
        cursor.close()

        return result


"""Zu Testzwecken können wir diese Datei bei Bedarf auch ausführen, 
um die grundsätzliche Funktion zu überprüfen.

Anmerkung: Nicht professionell aber hilfreich..."""
if (__name__ == "__main__"):
    r = Rating()
    r.set_id(1414)
    r.set_project(3)
    r.set_evaluator(7)
    r.set_to_be_assessed(8)
    r.set_grade(6.0)
    r.set_passed(1)

    with RatingMapper() as mapper:
        result = mapper.update(r)





    def create_rating(self, creation_time, project, evaluator, to_be_assessed,
                      grade, passed):
        """Ein Rating anlegen"""
        rating = Rating()
        rating.set_creation_time(creation_time)
        rating.set_project(project)
        rating.set_evaluator(evaluator)
        rating.set_to_be_assessed(to_be_assessed)
        rating.set_grade(grade)
        rating.set_passed(passed)
        rating.set_id(1)

        with RatingMapper() as mapper:
            return mapper.insert(rating)