def tags(cls):
if not hasattr(cls, "Tag"):
# Create the Tag model
tag_attrs = {
"id":
db.Column(db.Integer, primary_key=True),
"objects":
db.relationship(
cls,
secondary=lambda: cls.__tags_association_table__,
backref="related_tags",
),
}
cls.Tag = type(f"{cls.__name__}Tag", (ClassifierMixin, db.Model),
tag_attrs)
# The many-to-many association table
cls.__tags_association_table__ = _prepare_association_table(
table_name=f"{cls.__tablename__}s_tags",
remote1=cls.__tablename__,
remote2=cls.Tag.__tablename__,
)
return association_proxy(
"related_tags",
"title",
creator=lambda t: cls.Tag.get_or_create(title=t))
def last_edited_by(cls):
return db.relationship(
"User",
foreign_keys=[cls.editor_id],
info=dict(label=lazy_gettext("Author"),
description=lazy_gettext("")),
)
class User(db.Model, UserMixin, SQLAEvent):
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(
db.Unicode(128),
nullable=False,
unique=True,
index=True,
info=dict(
label=lazy_gettext("User Name"),
description=lazy_gettext(
"A unique name for this user (used for login)"),
),
)
email = db.Column(
db.String(255),
unique=True,
info=dict(label=lazy_gettext("Email"), description=lazy_gettext("")),
)
password = db.Column(
db.String(255),
info=dict(label=lazy_gettext("Password"),
description=lazy_gettext("")),
)
active = db.Column(
db.Boolean,
info=dict(
label=lazy_gettext("Active"),
description=lazy_gettext(
"Activate or deactivate this user account"),
),
)
confirmed_at = db.Column(db.DateTime(),
info=dict(label=lazy_gettext("Confirmed At")))
roles = db.relationship(
"Role",
secondary=roles_users,
backref=db.backref("users", lazy="dynamic"),
info=dict(label=lazy_gettext("Roles"), description=lazy_gettext("")),
)
# TODO: remove this one
name = property(fget=lambda self: self.profile.name)
@validates("password")
def validate_password(self, key, value):
"""TBD later"""
return value
@validates("email")
def validate_email(self, key, value):
if not is_valid_email(value):
raise ValueError("Invalid email address for %r" % self)
return value
def __str__(self):
return self.user_name
def __repr__(self):
return "User(user_name={})".format(self.user_name)
def category_id(cls):
if not hasattr(cls, "Category"):
category_attrs = {
"id": db.Column(db.Integer, primary_key=True),
"objects": db.relationship(cls, backref="category"),
}
cls.Category = type(f"{cls.__name__}Category",
(ClassifierMixin, db.Model), category_attrs)
return db.Column(db.Integer, db.ForeignKey(cls.Category.id))
def parent(cls):
return db.relationship(
cls,
remote_side=cls.id,
info=dict(
label="Parent Page",
description="The page under which this page will be added",
),
)
def children(cls):
return db.relationship(
cls,
lazy="dynamic",
join_depth=2,
cascade="all, delete-orphan",
order_by=f"{cls.__name__}.{cls.__children_ordering_column__}",
info=dict(label="Children", description=""),
)
class Profile(ImmutableProxiedDictMixin, db.Model, TimeStampped):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(
db.Integer,
db.ForeignKey("user.id"),
unique=True,
nullable=False,
info=dict(label=lazy_gettext("User")),
)
user = db.relationship(
User,
backref=backref("profile", uselist=False, cascade="all, delete-orphan"),
single_parent=True,
info=dict(label=lazy_gettext("User"), description=lazy_gettext("")),
)
extras = db.relationship(
"ProfileExtras", collection_class=attribute_mapped_collection("key")
)
_proxied = association_proxy("extras", "value")
def __repr__(self):
return f"<{self.user.user_name}: Profile()>"
def comments(cls):
if not hasattr(cls, "Comment"):
comment_attrs = {"id": db.Column(db.Integer, primary_key=True)}
cls.Comment = type(
f"{cls.__name__}Comment", (CommentMixin, db.Model), comment_attrs
)
# The many-to-many association table
cls.__comments_association_table__ = _prepare_association_table(
table_name=f"{cls.__tablename__}s_comments",
remote1=cls.__tablename__,
remote2=cls.Comment.__tablename__,
)
return db.relationship(
cls.Comment, secondary=cls.__comments_association_table__, backref="objects"
)
class Settings(ImmutableProxiedDictMixin, db.Model, SQLAEvent):
id = db.Column(db.Integer, primary_key=True)
store = db.relationship(
"Setting", collection_class=attribute_mapped_collection("key"))
_proxied = association_proxy("store", "value")
profile_id = db.Column(db.Integer,
db.ForeignKey("settings_profile.id"),
nullable=False)
def on_init(self):
process_func = lambda seq: [Field(**d) for d in seq if type(d) is dict]
ready = ((c, process_func(l))
for c, l in current_app.provided_settings)
for category, opts in ready:
for opt in opts:
setting = Setting(key=opt.name)
setting.value = opt.default
setting.category = str(category)
db.session.add(setting)
self.store[opt.name] = setting
class SettingsProfile(SQLAEvent, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(
db.Unicode(255),
unique=True,
nullable=False,
info=dict(
label="Profile Name:",
description="A Unique name for this settings profile.",
),
)
is_active = db.Column(
db.Boolean,
default=False,
info=dict(
label="Active",
description=
"Sets or unsets this settings profile as the default profile",
),
)
settings = db.relationship("Settings", backref="profile", uselist=False)
def on_init(self):
if self.settings is None:
self.settings = Settings()
def after_flush_postexec(self, session, is_modified):
if self.is_active:
thistbl = get_owning_table(self, "is_active")
up = (db.update(thistbl).where(
db.and_(thistbl.c.id != self.id,
thistbl.c.is_active == True)).values(is_active=False))
db.session.execute(up)
def __str__(self):
return self.name
def __repr__(self):
return "SettingsProfile(name='{}')".format(self.name)
