flaschengeist/geruecht/model/user.py

from geruecht.logger import getLogger
from geruecht.model.creditList import CreditList, create_empty_data
from datetime import datetime

LOGGER = getLogger(__name__)


class User():
    """ Database Object for User

        Table for all safed User

        Attributes:
            id: Id in Database as Primary Key.
            userID: ID for the User maybe to Link?
            username: Username of the User to Login
            firstname: Firstname of the User
            Lastname: Lastname of the User
            group: Which group is the User? moneymaster, gastro, user or bar?
            password: salted hashed password for the User.
    """
    def __init__(self, data):
        if 'id' in data:
            self.id = int(data['id'])
        self.uid = data['uid']
        self.dn = data['dn']
        self.firstname = data['firstname']
        self.lastname = data['lastname']
        self.group = data['gruppe']
        if 'statusgroup' in data:
            self.statusgroup = data['statusgroup']
        else:
            self.statusgroup = None
        if 'voting' in data:
            self.voting = data['voting']
        else:
            self.voting = None
        if 'mail' in data:
            self.mail = data['mail']
        else:
            self.mail = ''
        if 'lockLimit' in data:
            self.limit = int(data['lockLimit'])
        else:
            self.limit = 4200
        if 'locked' in data:
            self.locked = bool(data['locked'])
        else:
            self.locked = False
        if 'autoLock' in data:
            self.autoLock = bool(data['autoLock'])
        else:
            self.autoLock = True
        if type(data['gruppe']) == list:
            self.group = data['gruppe']
        elif type(data['gruppe']) == str:
            self.group = data['gruppe'].split(',')
        if 'creditLists' in data:
            self.geruechte = data['creditLists']
        self.password = ''

    def updateData(self, data):
        if 'dn' in data:
            self.dn = data['dn']
        if 'firstname' in data:
            self.firstname = data['firstname']
        if 'lastname' in data:
            self.lastname = data['lastname']
        if 'gruppe' in data:
            self.group = data['gruppe']
        if 'lockLimit' in data:
            self.limit = int(data['lockLimit'])
        if 'locked' in data:
            self.locked = bool(data['locked'])
        if 'autoLock' in data:
            self.autoLock = bool(data['autoLock'])
        if 'mail' in data:
            self.mail = data['mail']
        if 'statusgorup' in data:
            self.statusgroup = data['statusgroup']
        if 'voting' in data:
            self.voting = data['voting']

    def initGeruechte(self, creditLists):
        if type(creditLists) == list:
            self.geruechte = creditLists

    def createGeruecht(self, amount=0, year=datetime.now().year):
        """ Create Geruecht

            This function create a geruecht for the user for an year.
            By default is amount zero and year the actual year.

            Args:
                amount: is the last_schulden of the geruecht
                year: is the year of the geruecht

            Returns:
                the created geruecht
        """
        LOGGER.debug("Create Geruecht for user {} in year {}".format(self, year))
        data = create_empty_data()
        data['user_id'] = self.id
        data['last_schulden'] = amount
        data['year_date'] = year
        credit = CreditList(data)
        self.geruechte.append(credit)
        LOGGER.debug("Created Geruecht {}".format(credit))
        return credit

    def getGeruecht(self, year=datetime.now().year):
        """ Get Geruecht

            This function returns the geruecht of an year.
            By default is the year the actual year.

            Args:
                year: the year of the geruecht

            Returns:
                the geruecht of the year
        """
        LOGGER.debug("Iterate through Geruechte of User {}".format(self))
        for geruecht in self.geruechte:
            LOGGER.debug("Check if Geruecht {} has year {}".format(geruecht, year))
            if geruecht.year == year:
                LOGGER.debug("Find Geruecht {} for User {}".format(geruecht, self))
                return geruecht
        LOGGER.debug("No Geruecht found for User {}. Will create one".format(self))
        geruecht = self.createGeruecht(year=year)

        return self.getGeruecht(year=year)

    def addAmount(self, amount, year=datetime.now().year, month=datetime.now().month):
        """ Add Amount

            This function add an amount to a geruecht with an spezified year and month to the user.
            By default the year is the actual year.
            By default the month is the actual month.

            Args:
                year: year of the geruecht
                month: month for the amount

            Returns:
                double (credit, amount)
        """
        LOGGER.debug("Add amount to User {} in year {} and month {}".format(self, year, month))
        geruecht = self.getGeruecht(year=year)
        retVal = geruecht.addAmount(amount, month=month)

        return retVal

    def addCredit(self, credit, year=datetime.now().year, month=datetime.now().month):
        """ Add Credit

            This function add an credit to a geruecht with an spezified year and month to the user.
            By default the year is the actual year.
            By default the month is the actual month.

            Args:
                year: year of the geruecht
                month: month for the amount

            Returns:
                double (credit, amount)
        """
        LOGGER.debug("Add credit to User {} in year {} and month {}".format(self, year, month))
        geruecht = self.getGeruecht(year=year)
        retVal = geruecht.addCredit(credit, month=month)

        return retVal

    def updateGeruecht(self):
        """ Update list of geruechte

            This function iterate through the geruechte, which sorted by year and update the last_schulden of the geruecht.
        """
        LOGGER.debug("Update all Geruechte ")
        self.geruechte.sort(key=self.sortYear)

        for index, geruecht in enumerate(self.geruechte):
            if index == 0 or index == len(self.geruechte) - 1:
                geruecht.last_schulden = 0
            if index != 0:
                geruecht.last_schulden = (self.geruechte[index - 1].getSchulden() * -1)

        return self.geruechte

    def sortYear(self, geruecht):
        """ Sort Year

            This function is only an helperfunction to sort the list of geruechte by years.
            It only returns the year of the geruecht.

            Args:
                geruecht: geruecht which year you want

            Returns:
                int year of the geruecht
        """
        return geruecht.year

    def toJSON(self):
        """ Create Dic to dump in JSON

            Returns:
                A Dic with static Attributes.
        """
        dic = {
            "id": self.id,
            "userId": self.uid,
            "uid": self.uid,
            "dn": self.dn,
            "firstname": self.firstname,
            "lastname": self.lastname,
            "group": self.group,
            "username": self.uid,
            "locked": self.locked,
            "autoLock": self.autoLock,
            "limit": self.limit,
            "mail": self.mail,
            "statusgroup": self.statusgroup,
            "voting": self.voting
        }
        return dic

    def __repr__(self):
        return "User({}, {}, {})".format(self.uid, self.dn, self.group)