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))