class Authenticator(db.Model):
__tablename__ = 'authenticator_requests'
id = db.Column(db.Integer, primary_key=True)
_authenticator_hash = db.Column(db.Binary(128))
authenticator_public_key = db.Column(db.String(64), default="")
authenticator_type = db.Column(db.Enum(AuthenticatorType),
default=AuthenticatorType.USER)
code = db.Column(db.String(128), default="")
usage_limit = db.Column(db.Integer, default=1)
validity_type = db.Column(db.Enum(AuthenticatorValidityType),
default=AuthenticatorValidityType.ONCE)
creation_date = db.Column(ArrowType, default=arrow.utcnow)
expiration_date = db.Column(ArrowType, default=arrow.utcnow)
code_send_by = db.Column(db.Enum(AuthenticatorSendBy),
default=AuthenticatorSendBy.MAIL)
code_send_to = db.Column(db.String(128), default="")
@hybrid_property
def authenticator(self):
return self._authenticator_hash
@authenticator.setter
def authenticator(self, plaintext_authenticator):
self._authenticator_hash = bcrypt.generate_password_hash(
plaintext_authenticator)
@hybrid_method
def checkAuthenticator(self, plaintext_authenticator):
return bcrypt.check_password_hash(self.authenticator,
plaintext_authenticator)
class SpaceAccessGroup(db.Model):
__tablename__ = 'spaceaccess_groups'
id = db.Column(db.Integer, primary_key=True)
users = db.relationship(
"User",
backref=db.backref("spaceaccess_accessgroup", uselist=False, lazy=True),
secondary=AccessgroupUserMap.__tablename__,
lazy='subquery',
)
spaces = db.relationship(
"SpaceAccessSpace",
backref=db.backref("spaceaccess_accessgroup", lazy=True),
secondary=AccessgroupSpaceMap.__tablename__,
lazy='subquery',
)
name = db.Column(db.String(120), default="")
note = db.Column(db.String(120), default="")
access_type = db.Column(db.Enum(SpaceAccessType), default=SpaceAccessType.NO_ACCESS)
entry_accounting_type = db.Column(db.Enum(SpaceAccessEntryAccounting), default=SpaceAccessEntryAccounting.DAYS)
access_need_budget = db.Column(db.Boolean, default=False)
access_gets_recharged = db.Column(db.Boolean, default=False)
access_recharge_budget_amount = db.Column(db.Integer, default=15)
access_recharge_budget_period = db.Column(db.Enum(SpaceAccessRechargePeriod),
default=SpaceAccessRechargePeriod.MONTHS)
access_recharge_budget_every_periods = db.Column(db.Integer, default=4)
access_recharge_budget_get_cutoff = db.Column(db.Boolean, default=True)
access_recharge_budget_cutoff_max = db.Column(db.Integer, default=15)
access_expires_as_default = db.Column(db.Boolean, default=False)
access_expires_default_days = db.Column(db.Integer, default=365)
access_use_group_budget = db.Column(db.Boolean, default=False)
last_access_at = db.Column(ArrowType, default=None)
group_budget = db.Column(db.Integer, default=0)
day_access_mask = db.Column(db.Integer, default=127)
daily_access_start_time = db.Column(ArrowType, default=arrow.get('00:00', 'HH:mm'))
daily_access_end_time = db.Column(ArrowType, default=arrow.get('23:59', 'HH:mm'))
class Book(BaseModel, db.Model):
__tablename__ = 'books'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False)
category = db.Column(db.String(50))
price = db.Column(db.Float)
user_id = db.Column(db.Integer)
status = db.Column(db.Enum('0', '1'), default='0')
def __init__(self, name, category, price, user_id):
self.name = name
self.category = category
self.price = price
self.user_id = user_id
def __repr__(self):
return "<Book %r>" % self.name
def to_dict(self):
res_dict = {
'id': self.id,
'name': self.name,
'category': self.category,
'price': self.price,
'user_id': self.user_id,
'status': self.status
}
return res_dict
def delete(self):
self.status = "1"
return self.session_commit()
class Customers(db.Model):
"""This class represents the customers table."""
__tablename__ = 'customers'
customer_id = db.Column(db.BigInteger(), primary_key=True)
name = db.Column(db.String(255), nullable=False)
customer_class = db.Column(db.Enum('Enduser', 'Reseller', 'ResellerHighVolume', name='Enduser'))
vat_percentage = db.Column(db.Integer())
status = db.Column(db.Enum('Active', 'Deleted', name='customer_status'))
def __repr__(self):
return "<Customers: {}>".format(
self.customer_id,
self.name,
self.customer_class,
self.vat_percentage,
self.status
)
class Products(db.Model):
"""This class represents the products table."""
__tablename__ = 'products'
product_id = db.Column(db.BigInteger(), primary_key=True)
name = db.Column(db.String(255))
price_net = db.Column(db.Float(10,2))
status = db.Column(db.Enum('Active', 'Inactive', name='product_status'))
def __repr__(self):
return "<Products: {}>".format(
self.product_id,
self.name,
self.price_net,
self.status
)
class User(db.Model):
__tablename__ = 'users'
# nonvolatile data stored in the db
id = db.Column(db.Integer, primary_key=True)
_authenticator_hash = db.Column(db.Binary(128))
_password_hash = db.Column(db.Binary(128), nullable=False)
_pin_hash = db.Column(db.Binary(128))
_salt = db.Column(db.String(128))
authenticator_public_key = db.Column(db.String(64), default="")
authenticator_status = db.Column(db.Enum(UserAuthenticatorStatus),
default=UserAuthenticatorStatus.UNSET)
authenticator_changed_date = db.Column(ArrowType, default=arrow.utcnow)
email = db.Column(db.String(120), index=True, unique=True)
firstname = db.Column(db.String(64), default="")
lastname = db.Column(db.String(64), default="")
organization = db.Column(db.String(64), default="")
phone = db.Column(db.String(64), default="")
account_created_date = db.Column(ArrowType, default=arrow.utcnow)
last_login_date = db.Column(ArrowType, default=arrow.utcnow)
password_reset_expired_date = db.Column(ArrowType, default=arrow.utcnow)
password_reset_hash = db.Column(db.String(128), default="")
account_verified = db.Column(db.Boolean, default=False)
account_locked = db.Column(db.Boolean, default=False)
ldap = db.Column(db.Boolean, default=False)
admin = db.Column(db.Boolean, default=False)
budget = db.Column(db.Float, default=0)
pinIsLocked = db.Column(db.Boolean, default=False)
failedPinAttempts = db.Column(db.Integer(), default=0)
failedLoginAttempts = db.Column(db.Integer(), default=0)
# def __init__(self, **kwargs):
# super(User, self).__init__(**kwargs)
def __init__(self, email, password, isAdmin=False):
self.email = email
self.password = password
self.admin = isAdmin
def __repr__(self):
return '<User {} {} : {}>'.format(self.firstname, self.lastname,
self.email)
@hybrid_property
def password(self):
return self._password_hash
@password.setter
def password(self, plaintext_password):
self._password_hash = bcrypt.generate_password_hash(plaintext_password)
@hybrid_method
def checkPassword(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
@hybrid_property
def pin(self):
return self._pin_hash
@pin.setter
def pin(self, plaintext_pin):
self._pin_hash = bcrypt.generate_password_hash(plaintext_pin)
@hybrid_method
def checkPin(self, plaintext_pin):
if self.pin is None or self.pin == "":
return False
else:
return bcrypt.check_password_hash(self.pin, plaintext_pin)
@hybrid_property
def authenticator(self):
return self._authenticator_hash
@authenticator.setter
def authenticator(self, plaintext_authenticator):
self._authenticator_hash = bcrypt.generate_password_hash(
plaintext_authenticator)
@hybrid_method
def resetAuthenticatorHash(self):
self._authenticator_hash = None
@hybrid_method
def setAuthenticatorHash(self, authenticator_hash):
self._authenticator_hash = authenticator_hash
@hybrid_method
def checkAuthenticator(self, plaintext_authenticator):
if self.authenticator is None or self.authenticator == "":
return False
else:
return bcrypt.check_password_hash(self.authenticator,
plaintext_authenticator)