This repository has been archived on 2024-05-31. You can view files and clone it, but cannot push or open issues or pull requests.
devicehub-teal/ereuse_devicehub/resources/user/models.py

139 lines
4.6 KiB
Python
Raw Normal View History

2018-04-27 17:16:43 +00:00
from uuid import uuid4
from flask import current_app as app
from flask_login import UserMixin
2022-04-06 10:35:08 +00:00
from sqlalchemy import BigInteger, Boolean, Column, Sequence
2018-04-27 17:16:43 +00:00
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy_utils import EmailType, PasswordType
2021-04-13 16:33:15 +00:00
from teal.db import IntEnum
2018-04-27 17:16:43 +00:00
2019-01-21 15:08:55 +00:00
from ereuse_devicehub.db import db
2022-04-06 10:35:08 +00:00
from ereuse_devicehub.resources.enums import SessionType
2019-01-21 15:08:55 +00:00
from ereuse_devicehub.resources.inventory.model import Inventory
from ereuse_devicehub.resources.models import STR_SIZE, Thing
2018-04-27 17:16:43 +00:00
class User(UserMixin, Thing):
2018-04-27 17:16:43 +00:00
__table_args__ = {'schema': 'common'}
id = Column(UUID(as_uuid=True), default=uuid4, primary_key=True)
email = Column(EmailType, nullable=False, unique=True)
2022-04-06 10:35:08 +00:00
password = Column(
PasswordType(
max_length=STR_SIZE,
onload=lambda **kwargs: dict(
schemes=app.config['PASSWORD_SCHEMES'], **kwargs
),
)
)
2019-01-23 15:55:04 +00:00
token = Column(UUID(as_uuid=True), default=uuid4, unique=True, nullable=False)
active = Column(Boolean, default=True, nullable=False)
phantom = Column(Boolean, default=False, nullable=False)
2022-04-06 10:35:08 +00:00
inventories = db.relationship(
Inventory,
backref=db.backref('users', lazy=True, collection_class=set),
secondary=lambda: UserInventory.__table__,
collection_class=set,
)
2019-01-23 15:55:04 +00:00
# todo set restriction that user has, at least, one active db
2022-04-06 10:35:08 +00:00
def __init__(
self, email, password=None, inventories=None, active=True, phantom=False
) -> None:
"""Creates an user.
2019-01-23 15:55:04 +00:00
:param email:
:param password:
:param inventories: A set of Inventory where the user has
access to. If none, the user is granted access to the current
inventory.
:param active: allow active and deactive one account without delete the account
:param phantom: it's util for identify the phantom accounts
create during the trade actions
2019-01-23 15:55:04 +00:00
"""
inventories = inventories or {Inventory.current}
2022-04-06 10:35:08 +00:00
super().__init__(
email=email,
password=password,
inventories=inventories,
active=active,
phantom=phantom,
)
def __repr__(self) -> str:
return '<User {0.email}>'.format(self)
@property
def type(self) -> str:
return self.__class__.__name__
@property
def individual(self):
"""The individual associated for this database, or None."""
return next(iter(self.individuals), None)
2019-01-21 15:08:55 +00:00
2021-07-01 10:08:18 +00:00
@property
def code(self):
"""Code of phantoms accounts"""
if not self.phantom:
return
return self.email.split('@')[0].split('_')[1]
@property
def is_active(self):
"""Alias because flask-login expects `is_active` attribute"""
return self.active
@property
def get_full_name(self):
# TODO(@slamora) create first_name & last_name fields???
# needs to be discussed related to Agent <--> User concepts
return self.email
def check_password(self, password):
# take advantage of SQL Alchemy PasswordType to verify password
return self.password == password
2019-01-21 15:08:55 +00:00
class UserInventory(db.Model):
"""Relationship between users and their inventories."""
2022-04-06 10:35:08 +00:00
2019-01-21 15:08:55 +00:00
__table_args__ = {'schema': 'common'}
user_id = db.Column(db.UUID(as_uuid=True), db.ForeignKey(User.id), primary_key=True)
2022-04-06 10:35:08 +00:00
inventory_id = db.Column(
db.Unicode(), db.ForeignKey(Inventory.id), primary_key=True
)
2021-04-13 16:33:15 +00:00
class Session(Thing):
2021-05-24 11:00:03 +00:00
__table_args__ = {'schema': 'common'}
2021-04-13 16:33:15 +00:00
id = Column(BigInteger, Sequence('device_seq'), primary_key=True)
expired = Column(BigInteger, default=0)
token = Column(UUID(as_uuid=True), default=uuid4, unique=True, nullable=False)
type = Column(IntEnum(SessionType), default=SessionType.Internal, nullable=False)
user_id = db.Column(db.UUID(as_uuid=True), db.ForeignKey(User.id))
2022-04-06 10:35:08 +00:00
user = db.relationship(
User,
backref=db.backref('sessions', lazy=True, collection_class=set),
collection_class=set,
)
2021-04-15 19:18:15 +00:00
def __str__(self) -> str:
return '{0.token}'.format(self)
class SanitizationEntity(Thing):
id = Column(BigInteger, primary_key=True)
company_name = Column(db.String, nullable=True)
location = Column(db.String, nullable=True)
logo = Column(db.String, nullable=True)
responsable_person = Column(db.String, nullable=True)
user_id = db.Column(db.UUID(as_uuid=True), db.ForeignKey(User.id))
user = db.relationship(
User,
backref=db.backref('sanitization_entity', lazy=True, collection_class=set),
collection_class=set,
)
def __str__(self) -> str:
return '{0.company_name}'.format(self)