class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
class User(db.Model, SqlMixin):
__tablename__ = 'users'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
name = db.Column(db.String(16), unique=True, nullable=False)
cname = db.Column(db.String(16), unique=True, nullable=False)
pwd_hash = db.Column(db.String(100), nullable=False)
is_super = db.Column(db.Boolean, default=False)
status = db.Column(db.Boolean, default=True)
phone_number = db.Column(db.String(11), unique=True, nullable=False)
email = db.Column(db.String(32), unique=True, nullable=False)
access_token = db.Column(db.String(32))
token_expired = db.Column(db.Integer)
ctime = db.Column(db.DateTime, default=datetime.now)
login_time = db.Column(db.DateTime, default=datetime.now)
last_time = db.Column(db.DateTime, default=datetime.now)
groups = db.relationship('Group',
secondary='user_group',
backref=db.backref('users', lazy='dynamic'))
roles = db.relationship('Role',
secondary='user_role',
backref=db.backref('users', lazy='dynamic'))
permissions = db.relationship('Permission',
secondary='user_permission',
backref=db.backref('users', lazy='dynamic'))
@property
def password(self):
raise AttributeError('密码为私有属性，不允许访问')
@password.setter
def password(self, pwd):
self.pwd_hash = generate_password_hash(pwd)
def verify_password(self, pwd):
return check_password_hash(self.pwd_hash, pwd)
@staticmethod
def generate_auth_token():
return uuid.uuid4().hex
@staticmethod
def permission_join(p_set, p_obj_list):
for p_obj in p_obj_list:
p_set.add(p_obj.name)
return p_set
def get_permissions(self):
permission_set = set()
if self.is_super:
return set()
if self.permissions:
permission_set = self.permission_join(permission_set,
self.permissions)
if self.groups:
for group in self.groups:
if group.permissions:
permission_set = self.permission_join(
permission_set, group.permissions)
if self.roles:
for role in self.roles:
if role.permissions:
permission_set = self.permission_join(
permission_set, role.permissions)
return permission_set
def __repr__(self):
return '<User {}: {}>'.format(self.id, self.name)
class Meta:
ordering = ('-id', )
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
message_sent = db.relationship('Message',
foreign_keys='Message.sender_id',
backref='author',
lazy='dynamic')
message_received = db.relationship('Message',
foreign_keys='Message.recipient_id',
backref='recipient',
lazy='dynamic')
last_message_read_time = db.Column(db.DateTime)
notifications = db.relationship('Notification',
backref='user',
lazy='dynamic')
tasks = db.relationship('Task', backref='user', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
def new_messages(self):
last_read_time = self.last_message_read_time or datetime(1900, 1, 1)
return Message.query.filter_by(recipient=self).filter(
Message.timestamp > last_read_time).count()
def add_notification(self, name, data):
self.notifications.filter_by(name=name).delete()
n = Notification(name=name, payload_json=json.dumps(data), user=self)
db.session.add(n)
return n
def launch_task(self, name, description, *args, **kwargs):
rq_job = current_app.task_queue.enqueue('app.tasks.' + name, self.id,
*args, **kwargs)
task = Task(id=rq_job.get_id(),
name=name,
description=description,
user=self)
db.session.add(task)
return task
def get_tasks_in_progress(self):
return Task.query.filter_by(user=self, complete=False).all()
def get_task_in_progress(self, name):
return Task.query.filter_by(name=name, user=self,
complete=False).first()
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class Content(db.Model):
"""All contents indexed..."""
__tablename__ = 'contents'
__searchable__ = ['title']
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(2048), unique=True, nullable=False)
feed_id = db.Column(db.String(2048), unique=True, nullable=False)
title = db.Column(db.String(1000), index=True, nullable=False)
# convert to UTC before using
timestamp = db.Column(db.DateTime(), nullable=False)
description = db.Column(db.String(20000))
image_url = db.Column(db.String(2048))
icon_url = db.Column(db.String(2048))
rank = db.Column(db.Integer)
predicted_shares = db.Column(db.Integer)
real_shares = db.Column(db.Integer)
type_id = db.Column(db.Integer,
db.ForeignKey('content_types.id'),
index=True)
site_name_id = db.Column(db.Integer,
db.ForeignKey('site_names.id'),
index=True)
content_source_id = db.Column(db.Integer,
db.ForeignKey('content_sources.id'),
index=True)
feature_extraction = db.Column(db.String())
parent_cluster = db.Column(db.Integer)
social_shares = db.relationship('SocialShare', backref='content')
@classmethod
def create_or_update_content(cls, session, **kargs):
content = cls.get_content_by_link(kargs['url'])
if not content:
content = cls(url=kargs['url'],
title=kargs['title'],
raw_url=kargs['raw_url'],
content_source_id=kargs['source_id'],
timestamp=datetime.fromtimestamp(
mktime(kargs['timestamp'])))
if 'description' in kargs:
content.description = kargs['description']
if 'raw_html' in kargs:
content.raw_html = kargs['raw_html']
if 'content_type' in kargs:
contentType = ContentType.get_content_type(kargs['content_type'])
if contentType:
content.type = contentType
if 'site_name' in kargs:
siteName = SiteName.get_or_create_site_name(
session, kargs['site_name'])
content.siteName = siteName
if 'image_url' in kargs:
content.image_url = kargs['image_url']
if 'text' in kargs:
content.text = kargs['text']
if 'meta_tags' in kargs:
content.meta_tags = kargs['meta_tags']
if 'icon_url' in kargs:
content.icon_url = kargs['icon_url']
if 'tags' in kargs:
tagObjects = []
for tag in kargs['tags']:
tagObjects.append(Tag.get_or_create_tag(session, tag))
content.tags = tagObjects
session.add(content)
session.commit()
return content
@classmethod
def get_content_by_link(cls, url):
return cls.query.filter(cls.url == url).first()
@classmethod
def get_content_by_feed_id(cls, feed_id):
return cls.query.filter(cls.feed_id == feed_id).first()
@classmethod
def get_content_by_id(cls, content_id):
return cls.query.filter(cls.id == content_id).first()
@classmethod
def get_unranked_contents_by_age(cls, hours_ago):
return cls.query.filter(
and_(
cls.rank == None,
datetime.utcnow() - cls.timestamp >=
timedelta(hours=hours_ago))).all()
@classmethod
def get_content_no_real_shares_by_age(cls, days_ago):
return cls.query.filter(
and_(cls.real_shares == None,
datetime.utcnow() - cls.timestamp >=
timedelta(days=days_ago))).all()
@classmethod
def get_content_for_ranking(cls, days):
return cls.query.filter(
and_(
cls.social_shares != None,
or_(
cls.rank == None,
and_(
cls.social_shares != None,
datetime.utcnow() - cls.timestamp <=
timedelta(days=days))))).all()
@classmethod
def get_front_page(cls):
return cls.query.order_by(cls.rank.desc())[0:48]
@classmethod
def getFrontPageVideos(cls, session):
return session.query(Content, ContentType).filter(ContentType.type_string == 'video') \
.filter(Content.type_id == ContentType.id).order_by(Content.timestamp.desc())[0:30]
@classmethod
def getFrontPageArticles(cls, session):
return session.query(Content, ContentType).filter(ContentType.type_string == 'article') \
.filter(Content.type_id == ContentType.id).order_by(Content.timestamp.desc())[0:30]
@classmethod
def get_front_page_in_range(cls, start_idx, end_idx):
return cls.query.filter(cls.rank != None).order_by(
cls.rank.desc())[start_idx:end_idx]
@classmethod
def get_top_unviewed(cls, viewed=None):
if not viewed:
content = cls.query.filter(cls.rank != None) \
.order_by(cls.rank.desc())[0:TOP_CONTENTS_TO_SHUFFLE]
else:
content = cls.query.filter(and_(cls.rank != None, ~cls.id.in_(viewed))) \
.order_by(cls.rank.desc())[0:TOP_CONTENTS_TO_SHUFFLE]
random.shuffle(content)
return content[0:CONTENTS_PER_PAGE]
@classmethod
def get_top_by_pages(cls, page, viewed):
return cls.query.filter(and_(cls.rank != None, ~cls.id.in_(viewed))).order_by(cls.rank.desc()) \
.paginate(page, CONTENTS_PER_PAGE, False).items
@classmethod
def get_top_tag_filtered(cls, page, tags, viewed=None):
query = cls.query \
.join(TagContent, Content.id == TagContent.content_id) \
.join(Tag, Tag.id == TagContent.tag_id)
if viewed:
query = query.filter(
and_(cls.rank != None, Tag.tag_string.in_(tags),
~cls.id.in_(viewed)))
else:
query = query.filter(
and_(cls.rank != None, Tag.tag_string.in_(tags)))
return query.order_by(cls.rank.desc()).paginate(
page, CONTENTS_PER_PAGE, False).items
@classmethod
def get_top_type_filtered(cls, page, types, viewed=None):
query = cls.query \
.join(ContentType, ContentType.id == cls.type_id)
if viewed:
query = query.filter(
and_(cls.rank != None, ContentType.type_string.in_(types),
~cls.id.in_(viewed)))
else:
query = query.filter(
and_(cls.rank != None, ContentType.type_string.in_(types)))
return query.order_by(cls.rank.desc()).paginate(
page, CONTENTS_PER_PAGE, False).items
@classmethod
def get_top_for_query(cls, query, page):
end_idx = page * CONTENTS_PER_PAGE
start_idx = end_idx - CONTENTS_PER_PAGE
contents = cls.search_title_for(query).order_by(
cls.rank.desc())[start_idx:end_idx]
return contents
@classmethod
def search_title_for(cls, query):
return cls.query.whoosh_search(query)
def getFriendlyDescription(self):
"""Returns the description, truncated to 300 characters"""
if not self.description:
return ''
if len(self.title) > 65:
return self.description[:120] + '...'
return self.description[:200] + '...' if len(
self.description) > 200 else self.description
def get_shares_count(self):
return len(self.social_shares)
@property
def fp_serialize(self):
"""Returns the object serialized as a dict for front page use"""
serialized = {
'id': self.id,
'url': self.url,
'title': self.title,
'timestamp': self.timestamp,
'description': self.description,
'icon_url': self.icon_url,
'tags': [tag_str.tag_string for tag_str in self.tags],
}
if self.type:
serialized['type'] = self.type.type_string
if self.site_name:
serialized['site_name'] = self.site_name.site_name
if self.image_url:
serialized['image_url'] = self.image_url
else:
serialized['image_url'] = ""
if self.source.tag:
serialized['primary_tag'] = self.source.tag.tag_string
return serialized
def get_feature_extraction(self):
return json.loads(self.feature_extraction)
@classmethod
def get_raw_html_by_id(cls, content_id):
raw_html = ''
url = cls.get_content_by_id(content_id).url
try:
response = requests.get(url)
raw_html = response.text
except:
pass
return raw_html
@staticmethod
def ids_from_content_list(content_obj_list):
return [content.id for content in content_obj_list]
@classmethod
def get_id_title_description(cls, content_id_list):
data = []
for content_id in content_id_list:
content = cls.get_content_by_id(content_id)
data.append([content.id, content.title, content.description])
return data
@classmethod
def get_content_for_clustering(cls):
"""
@todo: include pre existing clusters + top ranked news
"""
#<================== HACK!!! ====================>
#non_clustered_content = cls.query.filter(cls.parent_cluster == None)
#non_clustered_content_id = cls.ids_from_content_list(non_clustered_content)
non_cluster = cls.none_parent_cluster()
num_clustered = cls.get_num_clustered(len(non_cluster))
clustered = cls.top_n_contents(num_clustered)
to_cluster = non_cluster[:] + clustered[:]
to_cluster_id = cls.ids_from_content_list(to_cluster)
return cls.get_id_title_description(to_cluster_id)
@classmethod
def get_content_by_parent_cluster(cls, parent_cluster):
return cls.query.filter(cls.parent_cluster == parent_cluster)
@classmethod
def top_n_contents(cls, n):
return cls.query.filter(
and_(datetime.utcnow() - cls.timestamp <= timedelta(hours=3), cls.rank != None))\
.order_by(cls.rank.desc())[:n]
@classmethod
def none_parent_cluster(cls):
return cls.query.filter(cls.parent_cluster == None)[:]
@staticmethod
def get_num_clustered(num_non_cluster):
if num_non_cluster <= 500:
return 500 - num_non_cluster
else:
return 100
class Card_colour(db.Model):
__tablename__ = 'Card_colour'
id = db.Column(db.Integer, primary_key=True)
card_id = db.Column(db.Integer, db.ForeignKey('Card.id'))
colour = db.Column(db.String(50))
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(300))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
# опередяем отношениие многие ко многим для фоловеров
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
# add follower
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
# remove follower
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
# to check connection between users
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
# эльфийский запрос к БД: получим отсортированные по дате посты юзеров, на которые подписан юзер
def followed_posts(self):
return Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).order_by(
Post.timestamp.desc())
# функции генерирования токенов
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class User(db.Model, UserMixin, RoleMixin):
"""
Provides User Model
"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# User Authentication Information (Required by Flask-User)
# we will use the users email as the primary means of login
email = db.Column(db.String(128), unique=True)
email_confirmed_at = db.Column(db.DateTime)
password = db.Column(db.String(256), nullable=False, server_default='')
active = db.Column(db.Boolean, nullable=False, server_default='0')
# Customizable Fields
full_name = db.Column(db.String(64), nullable=False, server_default='')
affiliation = db.Column(db.String(128))
expiration = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow() + timedelta(days=365))
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
date_updated = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
# Many To One relationship
affiliation_type_id = db.Column(db.Integer,
db.ForeignKey('affiliation_type.id'))
affiliation_type = db.relationship('AffiliationType')
# One To Many relationship
roles = db.relationship('Role',
secondary='users_roles',
backref=db.backref('users'))
def has_role(self, role):
"""
Utility function to check if user has a particular role
Args:
role: role to test against
Returns:
True if the user has the role, otherwise, False
"""
for item in self.roles:
if item.name == role:
return True
return False
def role(self): # To DO: is this needed
for item in self.roles:
return item.name
def add_role(self, role_name, add_to_roles=True):
"""
Utility function that can add roles to users
Args:
role_name: name of the role to add
add_to_roles: if True, it will add the role if it doesn't exist
if False, will only add if the role is there will return
False if it cannot
Result:
True if the role has been added to the user
False if the role cannot be added to the user
"""
# check if the role exists
if role_name is None:
return False
if self.has_role(role_name):
return True
rl = Role.query.filter(Role.name == role_name).first()
if rl is None:
if add_to_roles:
rl = Role(name=role_name, label=role_name)
else:
return False
self.roles.append(rl)
return True
def affiliation_type_key(self):
"""
Utility function to return the key for the affilaition type
"""
return self.affiliation_type.name
def associated_oauths(self):
"""
Utility function that returns the information about
the oauths this user has associated with
"""
oauths = OAuth.query.filter(OAuth.user == self).all()
return [(x.provider, x.provider_user_login, OAuth_pretty[x.provider])
for x in oauths]
def is_oauth_associated(self, provider_name):
if OAuth.query.filter(OAuth.user == self,
OAuth.provider == provider_name).first():
return True
else:
return False
def __repr__(self):
return '<User {}: {}>'.format(self.email, self.full_name)
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
activity = db.Column(db.String(80))
date = db.Column(db.String(15))
class SlidersHome(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
text = db.Column(db.Text)
video = db.Column(db.String(500))
active = db.Column(db.Boolean)
class Trip(db.Model, BaseMixin):
__tablename__ = 'trips'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), index=True, nullable=False)
type = db.Column(db.String(64), nullable=False)
departure_country = db.Column(db.String(64), nullable=False)
departure_port = db.Column(db.String(64), nullable=False)
arrival_country = db.Column(db.String(64), nullable=False)
arrival_port = db.Column(db.String(64), nullable=False)
planned_time = db.Column(db.String(64), nullable=False)
estimated_arrival_time = db.Column(db.String(64), nullable=False)
estimated_at_real_time = db.Column(db.String(64), nullable=False)
consignor = db.Column(db.String(64), nullable=False)
consignee = db.Column(db.String(64), nullable=False)
cargo = db.Column(db.String(64), nullable=False)
cargo_weight = db.Column(db.String(64), nullable=False)
total_cargo_weight = db.Column(db.String(64), nullable=False)
status = db.Column(db.String(64), nullable=False)
tr_ex = db.Column(db.String(64), nullable=False)
custom_reference = db.Column(db.String(64), nullable=False)
container_nr = db.Column(db.String(64), nullable=True)
container_type = db.Column(db.String(64), nullable=True)
car_type = db.Column(db.String(64), nullable=False)
car_model = db.Column(db.String(64), nullable=False)
number_plate = db.Column(db.String(64), nullable=False)
trailer_plate = db.Column(db.String(64), nullable=False)
carrier = db.Column(db.String(64), nullable=False)
class User(PaginatedAPIMixin, UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
token = db.Column(db.String(32), index=True, unique=True)
token_expiration = db.Column(db.DateTime)
points = db.Column(db.Integer, default=0)
lastlogin = db.Column(db.Integer) #this will be in ticks(seconds)
currstreak = db.Column(db.Integer) #min value = 1
multiplier = db.Column(db.Float) #multiplier float in the range of [1, 3]
achievement1 = db.Column(db.Integer, default=0)
achievement2 = db.Column(db.Integer, default=0)
achievement3 = db.Column(db.Integer, default=0)
achievement4 = db.Column(db.Integer, default=0)
achievement5 = db.Column(db.Integer, default=0)
achievement6 = db.Column(db.Integer, default=0)
achievement7 = db.Column(db.Integer, default=0)
achievement8 = db.Column(db.Integer, default=0)
achievement9 = db.Column(db.Integer, default=0)
achievement10 = db.Column(db.Integer, default=0)
quiz_taken = db.Column(db.Integer, default=0)
def to_dict(self, include_email=False):
data = {
'id': self.id,
'username': self.username,
'password_hash': self.password_hash,
'points': self.points,
'lastlogin': self.lastlogin,
'currstreak': self.currstreak,
'multiplier': self.multiplier,
'achievement1': self.achievement1,
'achievement2': self.achievement2,
'achievement3': self.achievement3,
'achievement4': self.achievement4,
'achievement5': self.achievement5,
'achievement6': self.achievement6,
'achievement7': self.achievement7,
'achievement8': self.achievement8,
'achievement9': self.achievement9,
'achievement10': self.achievement10
}
if include_email:
data['email'] = self.email
return data
# TODO: modify fields
def from_dict(self, data, new_user=False):
for field in ['username', 'email']:
if field in data:
setattr(self, field, data[field])
if new_user and 'password' in data:
self.set_password(data['password'])
def set_password(self, password):
self.password_hash = generate_password_hash(password, method='sha256')
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def get_token(self, expires_in=3600):
now = datetime.utcnow()
if self.token and self.token_expiration > now + datetime.timedelta(
seconds=60):
return self.token
self.token = base64.b64encode(os.urandom(24)).decode('utf-8')
self.token_expiration = now + datetime.timedelta(seconds=expires_in)
db.session.add(self)
return self.token
def revoke_token(self):
self.token_expiration = datetime.utcnow() - datetime.timedelta(
seconds=1)
@staticmethod
def check_token(token):
user = User.query.filter_by(token=token).first()
if user is None or user.token_expiration < datetime.utcnow():
return None
return user
def __repr__(self):
return '<User {}>'.format(self.username)
class Materials(db.Model):
__tablename__ = 'tMaterials'
MaterialID = db.Column(db.Integer, primary_key=True)
MaterialName = db.Column(db.String(20))
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
posts = db.relationship('Post', backref='author', lazy='dynamic')
comments = db.relationship('Comment', backref='author', lazy='dynamic')
name = db.Column(db.String(64))
location = db.Column(db.String(64))
about_me = db.Column(db.Text())
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
last_seen = db.Column(db.DateTime(), default=datetime.utcnow)
followed = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all,delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all,delete-orphan')
chats = db.relationship('Chat', backref='author', lazy='dynamic')
sessions = db.relationship('Session',
foreign_keys=[Session.user_id],
backref=db.backref('user', lazy='joined'),
lazy='dynamic',
cascade='all,delete-orphan')
new_messages_count = db.Column(db.Integer)
def __repr__(self):
return '<User %s ID %d>' % (self.username, self.id)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.role is None:
self.role = Role.query.filter_by(default=True).first()
self.save()
self.follow(self)
admin = User.query.filter_by(
username=current_app.config['ADMIN']).first()
if admin and admin != self:
Dialogue(admin, self, name=u'系统消息')
if not self.password_hash:
self.password = u'123456'
self.save()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
for comment_delete in self.comments:
comment_delete.delete()
for chat_delete in self.chats:
chat_delete.delete()
for post_delete in self.posts:
post_delete.delete()
for session_delete in self.sessions:
session_delete.delete()
db.session.delete(self)
db.session.commit()
@staticmethod
def add_self_follows():
for user in User.query.all():
if not user.is_following(user):
user.follow(user)
user.save()
@staticmethod
def add_admin():
admin = User(email=u'*****@*****.**',
username=u'Admin',
password=u'1234',
confirmed=True,
member_since=datetime.utcnow())
admin.role = Role.query.filter_by(name='Administrator').first()
admin.save()
@staticmethod
def add_test_user():
user = User(email=u'*****@*****.**',
username=u'tester',
password=u'1234',
confirmed=True,
member_since=datetime.utcnow())
user.save()
@staticmethod
def add_admin_dialogue(user_id):
for user in User.query.all():
if user.id != user_id:
Dialogue(User.query.get(user_id), user, name=u'系统消息')
def can(self, permissions):
return self.role is not None and \
(self.role.permissions & permissions) == permissions
def is_administrator(self):
return self.can(0xff)
def is_moderator(self):
return self.can(0x0f)
def ping(self):
self.new_messages_count = 0
self.last_seen = datetime.utcnow()
for session in self.sessions:
self.new_messages_count = self.new_messages_count + session.having_new_chats
self.save()
@property
def password(self):
raise AttributeError('密码不可用,只可用于赋值。')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
confirmed = db.Column(db.Boolean, default=False)
def generate_confirmation_token(self, confirm_type, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({confirm_type: self.id})
def confirm(self, token, confirm_type):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except (AttributeError, BadSignature):
return False
if data.get(confirm_type) != self.id:
return False
return True
def reset_password(self, token, new_password):
if self.confirm(token, 'reset_password'):
self.password = new_password
self.save()
return True
else:
return False
def follow(self, user):
if not self.is_following(user):
f = Follow(follower=self, followed=user)
f.save()
def not_follow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
f.delete()
def is_following(self, user):
return self.followed.filter_by(followed_id=user.id).first() is not None
def is_followed_by(self, user):
return self.followers.filter_by(
follower_id=user.id).first() is not None
@property
def followed_posts(self):
from app.models.post import Post
return Post.query.join(Follow, Follow.followed_id == Post.author_id) \
.filter(Follow.follower_id == self.id)
@property
def dialogues(self):
return Dialogue.query.join(Session, Session.dialogue_id == Dialogue.id) \
.filter(Session.user_id == self.id)
def get_message_from_admin(self, content, link_id=None, link_type=None):
admin = User.query.filter_by(
username=current_app.config['ADMIN']).first()
if not admin or self.id == admin.id:
admin_list = User.query.filter_by(role=Role.query.filter_by(
name='Administrator').first()).all()
for admin_new in admin_list:
if admin_new != admin:
admin = admin_new
break
dialogue = Dialogue.get_dialogue(admin, self)
if link_id and link_type:
dialogue.new_chat(author=admin,
content=content,
link_id=link_id,
link_type=link_type)
else:
dialogue.new_chat(author=admin, content=content)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), unique=True)
description = db.Column(db.String(255))
class Daily_status(db.Model):
email = db.Column(db.String(120), db.ForeignKey('user.email'), unique=True, primary_key=True)
status = db.Column(db.String(20), index=True, nullable=False)
def __repr__(self):
return '{}: {}'.format(self.email, self.status)
class AboutUs(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
text = db.Column(db.Text)
video = db.Column(db.String(500))
class Sample(db.Model):
"""
Samples model.
"""
__tablename__ = 'sample'
id = db.Column(db.Integer, primary_key=True)
# N-N relationships
family_id = db.Column(db.Integer, db.ForeignKey('family.id'))
check_list = db.relationship('CheckList',
secondary=sampletochecklist,
backref=db.backref('samples', lazy='dynamic'))
actions = db.relationship('IDAAction',
secondary=sampletoactions,
backref=db.backref('samples', lazy='dynamic'))
yaras = db.relationship('YaraRule',
secondary=sampletoyara,
backref=db.backref('samples', lazy='dynamic'))
# Enriched N-N relationships (double link)
linked_samples = db.relationship('SampleMatch',
backref=db.backref('sample1',
remote_side=[id]),
foreign_keys=[SampleMatch.sid_1])
linked_samples_2 = db.relationship('SampleMatch',
backref=db.backref('sample2',
remote_side=[id]),
foreign_keys=[SampleMatch.sid_2])
# 1-N relationships
strings = db.relationship("StringsItem",
backref=db.backref('sample', remote_side=[id]))
s_metadata = db.relationship("SampleMetadata",
backref=db.backref('sample',
remote_side=[id]))
functions = db.relationship("FunctionInfo",
backref=db.backref('sample', remote_side=[id]))
filenames = db.relationship("FileName",
backref=db.backref('sample', remote_side=[id]))
analysis_data = db.relationship('AnalysisResult',
backref=db.backref("sample",
remote_side=[id]))
# Sample's binary path
storage_file = db.Column(db.String())
# File size
size = db.Column(db.Integer())
# File's internal date (compilation timestamp, etc.)
file_date = db.Column(db.DateTime(), index=True)
# Hashes
md5 = db.Column(db.String(32), index=True, nullable=False)
sha1 = db.Column(db.String(40), index=True, nullable=False)
sha256 = db.Column(db.String(64), index=True, nullable=False)
# Mime type
mime_type = db.Column(db.String())
full_mime_type = db.Column(db.String())
# Abstract, set by user
abstract = db.Column(db.String())
# Import hash, set by tasks
import_hash = db.Column(db.String())
# TLP level, mandatory
TLP_sensibility = db.Column(db.Integer(),
nullable=False,
default=TLPLevel.TLPAMBER)
# Analysis status
analysis_status = db.Column(db.Integer(),
nullable=False,
default=AnalysisStatus.TOSTART)
# Sample's analysis date
analysis_date = db.Column(db.DateTime())
# "status" is not used, for now
# status = db.Column(db.Integer())
def __repr__(self):
return 'Sample %d' % self.id
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100))
email = db.Column(db.String(100))
password = db.Column(db.String(100))
name = db.Column(db.String(100))
class Admin(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), nullable=False)
sex = db.Column(db.String(2), nullable=False)
password = db.Column(db.String(6), nullable=False)
addtime = db.Column(db.DateTime, index=True, default=datetime.now)
class Client(db.Model):
id = db.Column(db.Integer, primary_key=True)
logo = db.Column(db.LargeBinary())
name = db.Column(db.String(500))
class User(db.Model):
__tablename__ = "tbl_user"
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
class ClientPhrases(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(500))
class Rulings(db.Model):
__tablename__ = 'Rulings'
id = db.Column(db.Integer, primary_key=True)
card_id = db.Column(db.Integer, db.ForeignKey('Card.id'))
ruling = db.Column(db.String(1000))
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
phone_1 = db.Column(db.String())
phone_2 = db.Column(db.String())
email = db.Column(db.String())
address_1 = db.Column(db.String())
address_2 = db.Column(db.String())
facebook = db.Column(db.String())
whatsapp = db.Column(db.String())
linkdeIn = db.Column(db.String())
instagram = db.Column(db.String())
blog = db.Column(db.String())
areaDoCliente = db.Column(db.String())
class Card_Supertypes(db.Model):
__tablename__ = 'Card_Supertypes'
id = db.Column(db.Integer, primary_key=True)
card_id = db.Column(db.Integer, db.ForeignKey('Card.id'))
supertype = db.Column(db.String(50))
class Methods(db.Model):
id = db.Column(db.Integer, primary_key=True)
image = db.Column(db.LargeBinary())
title = db.Column(db.String(100))
text = db.Column(db.Text())
class UUIDMixin(object):
id = db.Column(db.String(32), primary_key=True, default=lambda: generate_uuid4_string())
class User(UserMixin, db.Model):
first_name = db.Column(db.String(120), nullable=False)
last_name = db.Column(db.String(120), nullable=False, index=True)
gender = db.Column(db.String(20), nullable=False, index=True)
email = db.Column(db.String(120), unique=True, primary_key=True)
contact_number = db.Column(db.String(10))
password_hash = db.Column(db.String(128))
home_address = db.Column(db.String(120), index=True)
home_city = db.Column(db.String(120), index=True)
home_state = db.Column(db.String(2), index=True)
work_address = db.Column(db.String(120), index=True)
work_city = db.Column(db.String(120), index=True)
work_state = db.Column(db.String(2), index=True)
gender_preferred = db.Column(db.String(20), index=True)
signup_status = db.Column(db.String(20), index=True)
car = db.relationship('Car', uselist=False, backref='owner')
status = db.relationship('Daily_status', uselist=False, backref='employee')
def __repr__(self):
return 'User {} {}'.format(self.first_name, self.last_name)
def get_id(self):
return self.email
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
taskname = db.Column(db.String(500))
date = db.Column(db.DateTime, index=True, default=datetime.utcnow)
notes = db.Column(db.Text)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class ShopName(db.Model):
__tablename__ = 'tblShop_Names'
__table_args__ = {"schema": "dbo"}
Shop_Number = db.Column(db.Integer, primary_key=True)
Shop_Name = db.Column(db.String(30))
