class NaginieOption(db.Model, CRUDMixin):
__tablename__ = 'naginie_option'
key = db.Column(db.String(64), primary_key=True)
value = db.Column(db.String(128))
created = db.Column(db.DateTime(), default=datetime.datetime.now)
updated = db.Column(db.DateTime(), default=datetime.datetime.now)
def __repr__(self):
return '<NaginieOption key="%s" value="%s">' % (self.key, self.value)
@staticmethod
def set(key, value):
foption = NaginieOption.query.filter(NaginieOption.key == key).first()
if foption:
foption.value = value
foption.updated = datetime.datetime.now()
foption = NaginieOption(key=key, value=value)
db.session.add(foption)
db.session.commit()
@staticmethod
def rm(key):
foption = NaginieOption.query.filter(NaginieOption.key == key).first()
if foption:
db.session.delete(foption)
db.session.commmit()
class NaginieDirectory(db.Model, BaseNestedSets, CRUDMixin):
__tablename__ = 'naginie_directory'
id = db.Column(db.Integer, primary_key=True)
created = db.Column(db.DateTime(), default=datetime.datetime.now)
updated = db.Column(db.DateTime(), default=datetime.datetime.now)
slug = db.Column(db.String(128), unique=True)
title = db.Column(db.String(96))
description = db.Column(db.String(160))
is_blog = db.Column(db.Boolean, default=False)
is_public = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<NaginieDirectory id="%s" title="%s">' % (self.id, self.title)
def __unicode__(self):
return '%s' % self.title
def _to_dict(self):
return NaginieDirectory.to_dict(self)
@staticmethod
def to_dict(n_directory):
return {
'id': n_directory.id,
'parent_id': n_directory.parent_id,
'created': n_directory.created.isoformat(),
'updated': n_directory.updated.isoformat(),
'slug': n_directory.slug,
'title': n_directory.title,
'description': n_directory.description,
'is_blog': n_directory.is_blog
}
class NaginieFile(db.Model, CRUDMixin):
__tablename__ = 'naginie_file'
id = db.Column(db.Integer, primary_key = True)
created = db.Column(db.DateTime(), default=datetime.datetime.now)
updated = db.Column(db.DateTime(), default=datetime.datetime.now)
slug = db.Column(db.String(128), unique=True)
title = db.Column(db.String(96))
description = db.Column(db.String(160))
content = db.Column(db.Text())
is_md = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<NaginieFile id="%s" title="%s">' % (self.id, self.title)
def __unicode__(self):
return '%s' % self.title
def _to_dict(self):
return NaginieFile.to_dict(self)
@staticmethod
def to_dict(n_file, content=True):
return {
'id': n_file.id,
'created': n_file.created.isoformat(),
'updated': n_file.updated.isoformat(),
'slug': n_file.slug,
'title': n_file.title,
'description': n_file.description,
'content': n_file.content if content else None
}
class NaginieStatus(db.Model, CRUDMixin):
__tablename__ = 'naginie_status'
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(96))
description = db.Column(db.String(160))
role = db.Column(db.Enum(NaginieRole),
index=True,
nullable=False,
default='member')
users = db.relationship("NaginieUser",
back_populates="status",
lazy="joined",
order_by="desc(NaginieUser.id)")
def __repr__(self):
return '<NaginieStatus id="%s" title="%s" role="%s">' % (
self.id, self.title, self.role_str)
def __unicode__(self):
return '%s' % self.name
@hybrid_property
def role_str(self):
return str(self.role).replace("NaginieRole.", "")
def _to_dict(self):
return NaginieStatus.to_dict(self)
@staticmethod
def to_dict(n_status):
return {
'id': n_status.id,
'title': n_status.title,
'role': n_status.role_str,
'description': n_status.description,
'users': len(n_status.users)
}
class NaginieUser(db.Model, CRUDMixin):
__tablename__ = 'naginie_user'
id = db.Column(db.Integer, primary_key=True)
created = db.Column(db.DateTime(), default=datetime.datetime.now)
updated = db.Column(db.DateTime(), default=datetime.datetime.now)
logged = db.Column(db.DateTime(), default=datetime.datetime.now)
email = db.Column(db.String(120), unique=True, index=True, nullable=False)
username = db.Column(db.String(80), nullable=True)
lastname = db.Column(db.String(80), nullable=True)
firstname = db.Column(db.String(80), nullable=True)
_password = db.Column("password", db.String(120), nullable=False)
id_status = db.Column(db.Integer, db.ForeignKey("naginie_status.id"))
status = db.relationship("NaginieStatus",
back_populates="users",
lazy="joined",
uselist=False)
def _get_password(self):
return self._password
def _set_password(self, password):
if not password:
return
self._password = generate_password_hash(password)
password = db.synonym("_password",
descriptor=property(_get_password, _set_password))
email_verified = db.Column(db.Boolean, default=False)
tmp_hash = db.Column(db.String(80), index=True, unique=True, nullable=True)
def __repr__(self):
return '<NaginieStatus id="%s" nicename="%s">' % (self.id,
self.nicename)
def __unicode__(self):
return '%s' % self.nicename
def _to_dict(self, prev_next=False):
return NaginieUser.to_dict(self, prev_next)
@staticmethod
def to_dict(n_user, prev_next=False):
r = {
'id': n_user.id,
'nicename': n_user.nicename,
'email': n_user.email,
'username': n_user.username,
'lastname': n_user.lastname,
'firstname': n_user.firstname,
'created': n_user.created.isoformat(),
'updated': n_user.updated.isoformat(),
'logged': n_user.logged.isoformat(),
'status': n_user.status._to_dict() if n_user.status else False
}
if prev_next:
r['prev_next'] = n_user.prev_next
return r
@classmethod
def authenticate(cls, **kwargs):
email = kwargs.get('email')
password = kwargs.get('password')
if not email or not password:
return None
user = NaginieUser.query.filter(NaginieUser.email == email).first()
if user and user.check_password(password):
user.logged = datetime.datetime.now()
user.save()
return user
return None
def check_password(self, password):
if self.password == None:
return False
return check_password_hash(self.password, password)
@hybrid_property
def prev_next(self):
_n = NaginieUser.query.filter(NaginieUser.id > self.id).order_by(
NaginieUser.id.asc()).first()
_p = NaginieUser.query.filter(NaginieUser.id < self.id).order_by(
NaginieUser.id.desc()).first()
r = {
'next': _n.id if _n else False,
'prev': _p.id if _p else False,
}
return r
@hybrid_property
def nicename(self):
if self.username:
return self.username
elif self.firstname and self.lastname:
return '%s %s' % (self.firstname, self.lastname)
elif self.firstname:
return self.firstname
elif self.lastname:
return self.lastname
else:
return self.email.split('@')[0]
@staticmethod
def check_password_format(pwd):
if not pwd or pwd == "":
return 'Password can\'t be empty.'
elif len(pwd) > 32 or len(pwd) < 4:
return 'Password must be between 4 and 32 characters.'
return True
@staticmethod
def check_email_format(email):
if not email or email == "":
return 'E-mail can\'t be empty.'
elif "@" not in email or not re.search(r'(\w+[.|\w])*@(\w+[.])*\w+',
email):
return 'Incorrect e-mail.'
exist = NaginieUser.query.filter(NaginieUser.email == email).first()
if exist:
return 'E-mail already in use.'
return True