from hashlib import md5 from app import db from app import app import sys if sys.version_info >= (3, 0): enable_search = False else: enable_search = True import flask_whooshalchemy followers = db.Table( 'followers', db.Column('follower_id', db.Integer, db.ForeignKey('user.id')), db.Column('followed_id', db.Integer, db.ForeignKey('user.id')) ) user_like_movie= db.Table( "like", db.Column("user_id", db.Integer, db.ForeignKey("user.id")), db.Column("movie_id",db.Integer, db.ForeignKey("movie.id")) ) rating_comment=db.Table( "rate_comment", db.Column("user_id", db.Integer, db.ForeignKey("user.id")), db.Column("movie_id",db.Integer, db.ForeignKey("movie.id")), db.Column("content",db.String(300)), db.Column("rating",db.Float) )
class Snippet(db.Model): __tablename__ = "snippets" __table_args__ = (db.Index("iso_week_date", "year", "week"), ) id = db.Column(db.Integer, primary_key=True, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) text = db.Column(db.UnicodeText, nullable=False) year = db.Column(db.Integer, nullable=False) week = db.Column(db.Integer, nullable=False) tags = db.relationship( "Tag", secondary=tagged_snippets, backref=db.backref("snippets", lazy="dynamic"), lazy="dynamic", ) @staticmethod def load_from_json(user_id, json): """Loads a snippet from a dictionary. If an existing snippet with this date is found, that one is updated, committed to the database, and returned. Otherwise a new instance is populated, committed to the database, and returned. """ year = json["year"] week = json["week"] text = json.get("text", "") tags = json.get("tags", []) return Snippet.update(user_id, year, week, text, tags) def to_json(self): """Serializes this snippet to a dictionary.""" json = { "url": url_for( "api.get_week", year=self.year, week=self.week, ), "year": self.year, "week": self.week, "text": self.text or "", "tags": [tag.text for tag in self.tags], } return json @staticmethod def get_by_week(user_id: str, year: int, week: int) -> Optional[Snippet]: """Returns the specified snippet (or None if it does not exist).""" snippet = Snippet.query.filter_by(user_id=user_id, year=year, week=week) return snippet.first() @staticmethod def update(user_id: str, year: int, week: int, text: str, tags: List[str]): snippet = Snippet.get_by_week(user_id, year, week) if not snippet: snippet = Snippet(user_id=user_id, year=year, week=week) snippet.text = text snippet.tags = Tag.get_all(tags) db.session.add(snippet) db.session.commit() return snippet @staticmethod def get_all(user_id, tag_text=None) -> Query: """Returns a query for all the specified snippets.""" query = Snippet.query.filter_by(user_id=user_id) if tag_text: tag = Tag.query.filter_by(text=tag_text).first() tag_id = tag and tag.id query = query.join(tagged_snippets).filter_by(tag_id=tag_id) return query.order_by(Snippet.year.desc(), Snippet.week.desc()) def __repr__(self): return f"<Snippet {self.id} {self.user.email} {self.text} {self.year} {self.week}>"
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")) 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) avatar_hash = db.Column(db.String(32)) posts = db.relationship("Post", backref="author", lazy="dynamic") 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"), cascade="all, delete-orphan") comments = db.relationship("Comment", backref="author", lazy="dynamic") @property def password(self): raise AttributeError("password is not a readable attribute") @password.setter def password(self, password): self.password_hash = generate_password_hash(password) @property def followed_posts(self): return Post.query.join(Follow, Follow.followed_id == Post.author_id)\ .filter(Follow.follower_id == self.id) def verify_password(self, password): return check_password_hash(self.password_hash, password) def can(self, permissions): return self.role is not None and \ (self.role.permissions & permissions) == permissions def is_administrator(self): return self.can(Permission.ADMINISTER) def ping(self): self.last_seen = datetime.utcnow() db.session.add(self) def follow(self, user): if not self.is_following(user): f = Follow(follower=self, followed=user) db.session.add(f) def unfollow(self, user): f = self.followed.filter_by(followed_id=user.id).first() if f: db.session.delete(f) 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 # def gravatar(self, size=100, default="identicon", rating="g"): # if request.is_secure: # url = "https://secure.gravatar.com/avatar" # else: # url = "http://www.gravatar.com/avatar" # hash = self.avatar_hash or hashlib.md5( # self.email.encode("utf-8")).hexdigest() # return "{url}/{hash}?s={size}&d={default}&r={rating}".format( # url=url, hash=hash, size=size, default=default, rating=rating) @staticmethod def generate_fake(count=100): from sqlalchemy.exc import IntegrityError from random import seed import forgery_py seed() for i in range(count): u = User(email=forgery_py.internet.email_address(), username=forgery_py.internet.user_name(True), password=forgery_py.lorem_ipsum.word(), name=forgery_py.name.full_name(), location=forgery_py.address.city(), about_me=forgery_py.lorem_ipsum.sentence(), member_since=forgery_py.date.date(True)) db.session.add(u) try: db.session.commit() except IntegrityError: db.session.rollback() @staticmethod def add_self_follows(): for user in User.query.all(): if not user.is_following(user): user.follow(user) db.session.add(user) db.session.commit() def __init__(self, **kwargs): super(User, self).__init__(**kwargs) if self.role is None: if self.email == current_app.config["FLASKY_ADMIN"]: self.role = Role.query.filter_by(permissions=0xff).first() if self.role is None: self.role = Role.query.filter_by(default=True).first() if self.email is not None and self.avatar_hash is None: self.avatar_hash = hashlib.md5( self.email.encode("utf-8")).hexdigest() self.follow(self) def __repr__(self): return "<User {0}>".format(self.username)
from app import db, app from sqlalchemy.ext.hybrid import hybrid_property from flask_security import UserMixin, RoleMixin, current_user """ a third table must be created to relate users to roles by id. this is an example of a many-to-many relationship in SQLAlchemy i.e. a user can have many roles and roles can have many users """ roles_users = db.Table( 'roles_users', db.Column('user_id', db.Integer(), db.ForeignKey('user.id')), db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))) """ User: defines users and their attribles for the website Parents: db.Model, flask.ext.security.UserMixin """ class User(db.Model, UserMixin): id = db.Column(db.Integer(), primary_key=True) email = db.Column(db.String(255), index=True, unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) last_login_at = db.Column(db.DateTime) current_login_at = db.Column(db.DateTime) last_login_ip = db.Column(db.String(50)) current_login_ip = db.Column(db.String(50)) login_count = db.Column(db.Integer) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) """flask admin needs this to print the user correctly"""
import hashlib import flask_login import werkzeug from app import db, login @login.user_loader def load_user(id): return User.query.get(int(id)) _FOLLOWERS = db.Table( "followers", db.Column("follower_id", db.Integer, db.ForeignKey("user.id")), db.Column("followed_id", db.Integer, db.ForeignKey("user.id"))) class Post(db.Model): id = db.Column(db.Integer, primary_key=True) body = db.Column(db.String(140)) timestamp = db.Column(db.DateTime, index=True, default=datetime.datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) def __repr__(self): return '<Post {}>'.format(self.body)
class RolesUsers(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column('user_id', db.Integer, db.ForeignKey('user.id')) role_id = db.Column('role_id', db.Integer, db.ForeignKey('role.id'))
from flask_login import UserMixin from werkzeug.security import generate_password_hash, check_password_hash from app import db, login_manager @login_manager.user_loader def load_user(id): return User.query.get(int(id)) dictionary_table = db.Table( 'dictionary', db.Column('user_id', db.Integer, db.ForeignKey('user.id')), db.Column('word_id', db.Integer, db.ForeignKey('word.id'))) class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(70), nullable=False, unique=True) password = db.Column(db.String(94), nullable=False) first_name = db.Column(db.String(30), nullable=False) last_name = db.Column(db.String(30), nullable=False) dictionary = db.relationship('Word', secondary=dictionary_table, lazy='dynamic', backref=db.backref('users', lazy='dynamic')) created_at = db.Column(db.DateTime, default=db.func.now(), nullable=False) def generate_password_hash(self, password): self.password = generate_password_hash(password)
from datetime import datetime, timedelta from werkzeug.security import generate_password_hash, check_password_hash from flask_login import UserMixin from hashlib import md5 from time import time import json import jwt from app import db, login from app.search import add_to_index, query_index, remove_from_index from flask import current_app, url_for # from app.tasks import export_posts, on_task_progress followers = db.Table('followers', db.Column('follower_id', db.Integer, db.ForeignKey('user.id')), db.Column('followed_id', db.Integer, db.ForeignKey('user.id')) ) class PaginatedAPIMixin(object): @staticmethod def to_collection_dict(query, page, per_page, endpoint, **kwargs): resources = query.paginate(page, per_page, False) data = { 'items': [item.to_dict() for item in resources.items], '_meta': { 'page': page, 'per_page': per_page, 'total_pages': resources.pages,
from app import db import secrets from sqlalchemy.dialects.mysql import BIGINT, MEDIUMINT, INTEGER as INT, MEDIUMBLOB, TIMESTAMP, ENUM from datetime import datetime, timedelta guild_users = db.Table( 'guild_users', db.Column('guild', INT(unsigned=True), db.ForeignKey('guilds.id'), nullable=False), db.Column('user', INT(unsigned=True), db.ForeignKey('users.id'), nullable=False), db.Column('can_access', db.Boolean, nullable=False, default=False), db.UniqueConstraint('guild', 'user'), ) class User(db.Model): __tablename__ = 'users' id = db.Column(INT(unsigned=True), primary_key=True) user = db.Column(BIGINT(unsigned=True), unique=True) patreon = db.Column(db.Boolean, nullable=False, default=False) dm_channel = db.Column(INT(unsigned=True), db.ForeignKey('channels.id', ondelete='SET NULL'), nullable=False) channel = db.relationship('Channel')
class Maintenance(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) truck_id = db.Column(db.Integer, db.ForeignKey('truck.id')) price = db.Column(db.Float()) desc = db.Column(db.Float())
import os from app import app, db from flask_script import Manager from flask_migrate import Migrate, MigrateCommand migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) association = db.Table('association', db.Column('association_key', db.Integer, unique=True, primary_key=True), db.Column('user_id', db.Integer, db.ForeignKey('spotifyuser.id')), db.Column('artist_id', db.Integer, db.ForeignKey('artist.id')) ) class SpotifyUser(db.Model): __tablename__='spotifyuser' id = db.Column(db.Integer, primary_key = True) spotify_user_id = db.Column(db.String, unique = True, nullable=False) spotify_access_token = db.Column(db.String, unique=True) relevant_artists = db.relationship('Artist', secondary=association, backref = db.backref('spotifyusers', lazy=True)) class Artist(db.Model): __tablename__='artist' id = db.Column(db.Integer, unique=True, primary_key = True) artist_id = db.Column(db.String, unique=True) artist_name = db.Column(db.String, unique=True) interested_users = db.relationship('SpotifyUser', secondary=association, backref = db.backref('artists', lazy=True)) if __name__ == '__main__': manager.run()
class Payroll(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) employee_id = db.Column(db.Integer, db.ForeignKey('employee.id')) payment_total = db.Column(db.Float()) paid_toggle = db.Column(db.String(4))
class Notepad(db.Model): notepad_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(60), nullable=False) description = db.Column(db.String(300)) subject = db.Column(db.String(100), default="Other", nullable=False) public = db.Column(db.SmallInteger, default=NON_PUBLIC, nullable=False) day_to_repeat = db.Column(db.Integer, default=1, nullable=False) day_when_learned = db.Column(db.Date, default=datetime.now().date(), nullable=True) user_user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'), nullable=False) __table_args__ = (db.UniqueConstraint('name', 'user_user_id', name='names_uniq_constr'), ) def __repr__(self): return '<Notepad %r /%r/ %r>' % (self.name, self.day_to_repeat, self.day_when_learned) def get_cards_count(self): return Card.query.filter( Card.notepad_notepad_id == self.notepad_id).count() def is_public(self): return self.public == PUBLIC def add_card(self, first_part, last_part): params = { "notepad_notepad_id": self.notepad_id, "first_part": first_part, "last_part": last_part, "reverse_raiting": 0, "raiting": 0, "card_type": 0, "known": False } new_card = Card(**params) db.session.add(new_card) def repead_through(self): dif = (datetime.now().date() - self.day_when_learned).days return self.day_to_repeat - dif def get_owner(self): return User.query.filter_by(user_id=self.user_user_id) def is_learned(self): user = self.get_owner().first() user_notepads_checked = user.check_notepads() return self not in user_notepads_checked def get_cards(self, random=False): if random: return self.__get_random_cards() else: return Card.query.filter_by(notepad_notepad_id=self.notepad_id) def __get_random_cards(self): return self.get_cards().order_by(func.random()) def clear_cards(self): self.get_cards().delete() def deserialize(self, json_string): json_data = json.loads(json_string) self.name = json_data["notepad_name"] self.description = json_data["notepad_description"] self.subject = json_data["notepad_subject"] self.public = f'{0 if json_data["public"] == False else 1}' self.day_to_repeat = 1 self.day_when_learned = datetime.now().date() self.clear_cards() for card in json_data["cards"]: self.add_card(card["first_part"], card["last_part"]) def to_json(self): notepad = { 'notepad_id': self.notepad_id, 'notepad_name': self.name, 'notepad_description': self.description, 'notepad_subject': self.subject, 'public': self.public, 'cards': [{ "card_id": i.card_id, "fisrt_part": i.first_part, "last_part": i.last_part } for i in self.get_cards()] } myJson = json.dumps(notepad) return myJson @staticmethod def get_public_notepads(): return Notepad.query.filter_by(public=PUBLIC) @staticmethod # TODO тут нужно еще возвращать и свои приватные. # Это для поиска!!! def get_notepads_by_name(name): return Notepad.query.filter_by(name=name, public=PUBLIC).all()
class Ps_endpoints(db.Model): __tablename__ = 'ps_endpoints' id = db.Column(db.Integer, primary_key=True) transport = db.Column(db.String(40), nullable=True, default='transport-udp') context = db.Column(db.String(254), index=True) disallow = db.Column(db.String(40), nullable=True, default='all') allow = db.Column(db.String(40), nullable=True, default='alaw') direct_media = db.Column(db.Enum(BoolEnum), default='no') connected_line_method = db.Column(db.Enum(Connected_line_method)) direct_media_method = db.Column(db.Enum(Connected_line_method)) direct_media_glare_mitigation = db.Column(db.Enum(Direct_media_glare_mitigation)) disable_direct_media_on_nat = db.Column(db.Enum(BoolEnum)) dtmf_mode = db.Column(db.Enum(Dtmf_mode)) external_media_address = db.Column(db.String(40), nullable=True) force_rport = db.Column(db.Enum(BoolEnum)) ice_support = db.Column(db.Enum(BoolEnum)) identify_by = db.Column(db.String(80), nullable=True) mailboxes = db.Column(db.String(40), nullable=True) moh_suggest = db.Column(db.String(40), nullable=True) outbound_auth = db.Column(db.String(40), nullable=True) outbound_proxy = db.Column(db.String(40), nullable=True) rewrite_contact = db.Column(db.Enum(BoolEnum)) rtp_ipv6 = db.Column(db.Enum(BoolEnum)) rtp_symmetric = db.Column(db.Enum(BoolEnum)) send_diversion = db.Column(db.Enum(BoolEnum)) send_pai = db.Column(db.Enum(BoolEnum)) send_rpid = db.Column(db.Enum(BoolEnum)) timers_min_se = db.Column(db.Integer, nullable=True) timers = db.Column(db.Enum(Timers)) timers_sess_expires = db.Column(db.Integer, nullable=True) callerid = db.Column(db.String(254), nullable=True) callerid_privacy = db.Column(db.Enum(Callerid_privacy)) callerid_tag = db.Column(db.String(40), nullable=True) aggregate_mwi = db.Column(db.Enum(BoolEnum)) trust_id_inbound = db.Column(db.Enum(BoolEnum)) trust_id_outbound = db.Column(db.Enum(BoolEnum)) use_ptime = db.Column(db.Enum(BoolEnum)) use_avpf = db.Column(db.Enum(BoolEnum)) media_encryption = db.Column(db.Enum(Media_encryption)) inband_progress = db.Column(db.Enum(BoolEnum)) call_group = db.Column(db.Integer) pickup_group = db.Column(db.Integer) named_call_group = db.Column(db.String(40), nullable=True) named_pickup_group = db.Column(db.String(40), nullable=True) device_state_busy_at = db.Column(db.Integer) fax_detect = db.Column(db.Enum(BoolEnum)) t38_udptl = db.Column(db.Enum(BoolEnum)) t38_udptl_ec = db.Column(db.Enum(T38_udptl_ec)) t38_udptl_maxdatagram = db.Column(db.Integer) t38_udptl_nat = db.Column(db.Enum(BoolEnum)) t38_udptl_ipv6 = db.Column(db.Enum(BoolEnum)) tone_zone = db.Column(db.String(40), nullable=True) language = db.Column(db.String(40), nullable=True) one_touch_recording = db.Column(db.Enum(BoolEnum)) record_on_feature = db.Column(db.String(40), nullable=True) record_off_feature = db.Column(db.String(40), nullable=True) rtp_engine = db.Column(db.String(40), nullable=True) allow_transfer = db.Column(db.Enum(BoolEnum)) allow_subscribe = db.Column(db.Enum(BoolEnum)) sdp_owner = db.Column(db.String(40), nullable=True) sdp_session = db.Column(db.String(40), nullable=True) tos_audio = db.Column(db.String(10), nullable=True) tos_video = db.Column(db.String(10), nullable=True) sub_min_expiry = db.Column(db.Integer) from_domain = db.Column(db.String(40), nullable=True) from_user = db.Column(db.String(40), nullable=True) mwi_from_user = db.Column(db.String(40), nullable=True) dtls_verify = db.Column(db.String(40), nullable=True) dtls_rekey = db.Column(db.String(40), nullable=True) dtls_cert_file = db.Column(db.String(254), nullable=True) dtls_private_key = db.Column(db.String(254), nullable=True) dtls_ca_file = db.Column(db.String(254), nullable=True) dtls_ca_path = db.Column(db.String(254), nullable=True) dtls_setup = db.Column(db.Enum(Dtls_setup)) srtp_tag_32 = db.Column(db.Enum(BoolEnum)) media_address = db.Column(db.String(40), nullable=True) redirect_method = db.Column(db.Enum(Redirect_method)) set_var = db.Column(db.String(254), nullable=True) cos_audio = db.Column(db.Integer) cos_video = db.Column(db.Integer) message_context = db.Column(db.String(40), nullable=True) force_avp = db.Column(db.Enum(BoolEnum)) media_use_received_transport = db.Column(db.Enum(BoolEnum)) accountcode = db.Column(db.String(80), nullable=True) user_eq_phone = db.Column(db.Enum(BoolEnum)) moh_passthrough = db.Column(db.Enum(BoolEnum)) media_encryption_optimistic = db.Column(db.Enum(BoolEnum)) rpid_immediate = db.Column(db.Enum(BoolEnum)) g726_non_standard = db.Column(db.Enum(BoolEnum)) rtp_keepalive = db.Column(db.Integer) rtp_timeout = db.Column(db.Integer) rtp_timeout_hold = db.Column(db.Integer) bind_rtp_to_media_address = db.Column(db.Enum(BoolEnum)) voicemail_extension = db.Column(db.String(40), nullable=True) mwi_subscribe_replaces_unsolicited = db.Column(db.Enum(LongBoolEnum)) deny = db.Column(db.String(254), nullable=True) permit = db.Column(db.String(254), nullable=True) acl = db.Column(db.String(40), nullable=True) contact_deny = db.Column(db.String(254), nullable=True) contact_permit = db.Column(db.String(254), nullable=True) contact_acl = db.Column(db.String(40), nullable=True) subscribe_context = db.Column(db.String(40), nullable=True) fax_detect_timeout = db.Column(db.Integer) contact_user = db.Column(db.String(254), nullable=True) preferred_codec_only = db.Column(db.Enum(BoolEnum)) asymmetric_rtp_codec = db.Column(db.Enum(BoolEnum)) rtcp_mux = db.Column(db.Enum(BoolEnum)) allow_overlap = db.Column(db.Enum(BoolEnum)) refer_blind_progress = db.Column(db.Enum(BoolEnum)) notify_early_inuse_ringing = db.Column(db.Enum(BoolEnum)) max_audio_streams = db.Column(db.Integer) max_video_streams = db.Column(db.Integer) webrtc = db.Column(db.Enum(BoolEnum)) dtls_fingerprint = db.Column(db.Enum(Dtls_fingerprint)) incoming_mwi_mailbox = db.Column(db.String(254), nullable=True) bundle = db.Column(db.Enum(BoolEnum)) dtls_auto_generate_cert = db.Column(db.Enum(BoolEnum)) follow_early_media_fork = db.Column(db.Enum(BoolEnum)) accept_multiple_sdp_answers = db.Column(db.Enum(BoolEnum)) suppress_q850_reason_headers = db.Column(db.Enum(BoolEnum)) trust_connected_line = db.Column(db.Enum(LongBoolEnum)) send_connected_line = db.Column(db.Enum(LongBoolEnum)) ignore_183_without_sdp = db.Column(db.Enum(LongBoolEnum)) codec_prefs_incoming_offer = db.Column(db.String(254), nullable=True) codec_prefs_outgoing_offer = db.Column(db.String(254), nullable=True) codec_prefs_incoming_answer = db.Column(db.String(254), nullable=True) codec_prefs_outgoing_answer = db.Column(db.String(254), nullable=True) stir_shaken = db.Column(db.Enum(LongBoolEnum)) send_history_info = db.Column(db.Enum(LongBoolEnum)) auth = db.Column(db.Integer, db.ForeignKey('ps_auths.id')) aor = db.Column(db.Integer, db.ForeignKey('ps_aors.id')) # ps_aor = db.relationship("Ps_aors", back_populates="r_aors", cascade='all,delete-orphan') # ps_auth = db.relationship("Ps_auths", back_populates="r_auths", cascade='all,delete-orphan') def __init__(self, id, context, dtmf_mode, callerid, call_group, pickup_group, auth ,aor): self.id = id self.context = context self.dtmf_mode = dtmf_mode self.callerid = callerid self.call_group = call_group self.pickup_group = pickup_group self.auth = auth self.aor = aor
def verifypassword(self, password): """ Check if hashed password matches actual password """ return self.password_hash == password def __repr__(self): return '<Teacher: {}>'.format(self.username) def get_id(self): return unicode(self.name) registrations = db.Table( 'registrations', db.Column('studentName', db.String(60), db.ForeignKey('students.name')), db.Column('courseNums', db.String(60), db.ForeignKey('courses.courseNums'))) class Student(UserMixin, db.Model): __tablename__ = 'students' name = db.Column(db.String(60), nullable=False, primary_key=True) realname = db.Column(db.String(30), nullable=False) password_hash = db.Column(db.String(128), nullable=False) isTeacher = db.Column(db.Boolean(), default=False) courses = db.relationship('Course', secondary=registrations, backref=db.backref('students', lazy='dynamic'), lazy='dynamic')
class Reminder(db.Model): __tablename__ = 'reminders' id = db.Column(INT(unsigned=True), primary_key=True, unique=True) uid = db.Column(db.String(64), unique=True, default=lambda: Reminder.create_uid()) name = db.Column(db.String(24), default='Reminder') channel_id = db.Column(INT(unsigned=True), db.ForeignKey(Channel.id), nullable=True) channel = db.relationship(Channel, backref='reminders') utc_time = db.Column(db.DateTime, nullable=False) username = db.Column(db.String(32), nullable=True) avatar = db.Column(db.String(512), nullable=True) tts = db.Column(db.Boolean, nullable=False, default=False) content = db.Column(db.String(2048), nullable=False, default='') embed_title = db.Column(db.String(256), default='') embed_description = db.Column(db.String(2048), default='') embed_image_url = db.Column(db.String(512)) embed_thumbnail_url = db.Column(db.String(512)) embed_footer = db.Column(db.String(2048), default='') embed_footer_url = db.Column(db.String(512)) embed_author = db.Column(db.String(256), default='') embed_author_url = db.Column(db.String(512)) embed_color = db.Column(MEDIUMINT(unsigned=True), default=0) attachment = db.Column(MEDIUMBLOB, nullable=True) attachment_name = db.Column(db.String(260), nullable=True) pin = db.Column(db.Boolean, nullable=False, default=False) interval = db.Column(INT(unsigned=True)) restartable = db.Column(db.Boolean, nullable=False, default=False) enabled = db.Column(db.Boolean, nullable=False, default=True) expires = db.Column(db.DateTime) set_by = db.Column(INT(unsigned=True), db.ForeignKey(User.id, ondelete='SET NULL'), nullable=True) set_at = db.Column(db.TIMESTAMP, nullable=True, default=datetime.now, server_default='CURRENT_TIMESTAMP') fields = db.relationship(EmbedField, lazy='dynamic') @staticmethod def create_uid(): full: str = '' while len(full) < 64: full += secrets.choice( '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_' ) return full def hex_color(self): return hex(self.embed_color)[2:] def message_content(self): if len(self.content) > 0: return self.content else: return self.embed_description
class LaborPorProceso(db.Model): id_lxp = db.Column(db.Integer,primary_key=True) codigo = db.Column(db.String(8), db.ForeignKey('persona.codigo'))#en Foreign key se usa el nombre de la tabla idproceso = db.Column(db.Integer,db.ForeignKey('proceso.idproceso'))#en Foreign key se usa el nombre de la tabla es_coord = db.Column(db.Integer) es_apoyo = db.Column(db.Integer) es_asistente = db.Column(db.Integer) aula = db.Column(db.String(10)) aula_coord = db.Column(db.String(10)) aula_capacitacion = db.Column(db.String(10)) fecha_proceso = db.Column(db.Date) fecha_capacitacion = db.Column(db.Date) hora_proceso = db.Column(db.Time) hora_capacitacion = db.Column(db.Time) cod_coord = db.Column(db.String(8)) calificacion = db.Column(db.String(10)) obs_proceso = db.Column(db.String(255)) obs_capacitacion = db.Column(db.String(255)) obs_coordinacion = db.Column(db.String(255)) password = db.Column(db.String(255)) def __init__(self,codigo,idproceso,es_coord,es_apoyo,es_asistente,aula,aula_coord,aula_capacitacion,fecha_proceso, fecha_capacitacion,hora_proceso,hora_capacitacion,cod_coord,calificacion,obs_proceso,obs_capacitacion,obs_coordinacion,password): self.codigo = codigo self.idproceso = idproceso self.es_coord = es_coord self.es_apoyo = es_apoyo self.es_asistente = es_asistente self.aula = aula self.aula_coord = aula_coord self.aula_capacitacion = aula_capacitacion self.fecha_proceso = fecha_proceso self.fecha_capacitacion = fecha_capacitacion self.hora_proceso = hora_proceso self.hora_capacitacion = hora_capacitacion self.cod_coord = cod_coord self.calificacion = calificacion self.obs_proceso = obs_proceso self.obs_capacitacion = obs_capacitacion self.obs_coordinacion = obs_coordinacion self.password = password def __repr__(self): return '<Controlador %r>' % self.codigo def getAsDictEval(self,rel_level=0): result={} result["codigo"] = self.codigo result["idproceso"] = self.idproceso result["es_coord"] = self.es_coord result["es_apoyo"] = self.es_apoyo result["es_asistente"] = self.es_asistente result["aula"] = self.aula result["aula_coord"] = self.aula_coord result["aula_capacitacion"] = self.aula_capacitacion result["fecha_proceso"] = self.fecha_proceso result["fecha_capacitacion"] = self.fecha_capacitacion result["hora_proceso"] = self.hora_proceso result["hora_capacitacion"] = self.hora_capacitacion result["cod_coord"] = self.cod_coord result["calificacion"] = self.calificacion result["obs_proceso"] = self.obs_proceso result["obs_capacitacion"] = self.obs_capacitacion result["obs_coordinacion"] = self.obs_coordinacion result["password"] = self.password if rel_level > 0: result["persona"] = self.persona.getAsDict(rel_level-1) result["proceso"] = self.proceso.getAsDict(rel_level-1) else: result["persona"] = self.codigo result["proceso"] = self.idproceso return result
from app import db from sqlalchemy_utils import UUIDType # Many-to-many relationship association table between and activity and a user. participation = db.Table( 'participation', db.Column('activity_uuid', UUIDType, db.ForeignKey('activities.uuid')), db.Column('user_uuid', UUIDType, db.ForeignKey('users.uuid')))
class Drinks(db.Model): id = db.Column(db.Integer, primary_key=True) isDrinking = db.Column(db.Boolean) drinkTime = db.Column(db.DateTime, index=True, default=datetime.utcnow()) user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
from app import db from sqlalchemy.orm import validates DUPLICATE_PARAMETER = '{} with such {} is already in database' DEFAULT_DICT = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0} books_authors = db.Table( 'books_authors', db.Column('author_id', db.Integer, db.ForeignKey('authors.id'), primary_key=True), db.Column('book_id', db.Integer, db.ForeignKey('books.id'), primary_key=True)) class Author(db.Model): """ Authors model """ __tablename__ = 'authors' id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True) name = db.Column(db.String, unique=True, nullable=False) books = db.relationship("Book", secondary=books_authors, back_populates='authors') @property def serialized_all(self):
class Job(db.Model): __tablename__ = 'Jobs' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(120)) jobType = db.Column(db.String(64)) description = db.Column(db.String(500)) duration = db.Column(db.String(20)) location = db.Column(db.String(128)) timeStamp = db.Column(db.DateTime, index=True, default=datetime.utcnow) salary = db.Column(db.String(20)) postType = db.Column(db.String(100)) maxWorker = db.Column(db.Integer) userId = db.Column(db.Integer, db.ForeignKey('Users.id')) workers = db.relationship('Works', back_populates='worked_job') def notification_count(self): w = Works.query.filter(Works.jobID == self.id) n = 0 for worker in w: if worker.status == 'Not Working Not Read': n = n + 1 if worker.status == 'Done Not Read': n = n + 1 return n def worker_count(self): w = Works.query.filter(Works.jobID == self.id) n = 0 for worker in w: if worker.status == 'Working': n = n + 1 return n def hiring_count(self): w = Works.query.filter(Works.jobID == self.id) n = 0 for worker in w: if worker.status == 'Hiring': n = n + 1 return n def applying_count(self): w = Works.query.filter(Works.jobID == self.id) n = 0 for worker in w: if worker.status == 'Not Working Read': n = n + 1 return n def is_full(self): w = Works.query.filter(Works.jobID == self.id) n = 0 for worker in w: if worker.status == 'Working': n = n + 1 if n == len(self.workers): return True else: return False def __repr__(self): return f'Posted by {self.user}.'
class TasksModel(db.Model): __tablename__ = 'tasks' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(30), nullable=False, unique=False) description = db.Column(db.String(), nullable=False, unique=False) date_created = db.Column(db.DateTime, default=datetime.now) date_started = db.Column(db.DateTime) date_completed = db.Column(db.DateTime) date_cancelled = db.Column(db.DateTime) status = db.Column(db.Integer, default=0) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) # creating a new record # instance method: accesses only that instance of the class def insert_record(self): db.session.add(self) db.session.commit() return self # fetch all records @classmethod def fetch_all(cls): return cls.query.all() # update record by id # class instance accesses all the instances of that class @classmethod def update_by_id(cls, id, title=None, description=None, status=None): # 0 = todo , 1 = ongoing, 2 = completed, 3 = cancelled record = cls.query.filter_by(id=id).first() current_status = record.status if record: if title: record.title = title if description: record.description = description if status: if status == current_status: pass else: if status == 0: #todo state record.status = status record.date_started = record.date_completed = record.date_cancelled = None elif status == 1: #ongoing record.date_started = datetime.now() record.status = status record.date_completed = record.date_cancelled = None elif status == 2: #completed record.date_completed = datetime.now() record.status = status record.date_cancelled = None elif status == 3: #cancelled record.date_cancelled = datetime.now() record.status = status record.date_completed = None else: pass db.session.commit() return cls.query.filter_by(id=id).first() # deleting a record by id @classmethod def delete_by_id(cls, id): record = cls.query.filter_by(id=id) if record.first(): record.delete() db.session.commit() return True return False
class User(UserMixin,db.Model): """用户""" __tablename__ = 'users' id = db.Column(db.Integer,primary_key=True,autoincrement=True) username = db.Column(db.String(20),unique=True,nullable=False) password_hash = db.Column(db.String(200)) email = db.Column(db.String(20),unique=True,index=True) phone = db.Column(db.String(20)) gender = db.Column(db.String(20)) confirmed = db.Column(db.Boolean,default=False) # 账户是否已经确认 name = db.Column(db.String(60)) # 用户真实姓名 location = db.Column(db.String(60)) # 所在地 about_me = db.Column(db.Text()) # 自我介绍 # 注册日期 # default参数可以接收函数作为默认值 # 所以每次生成默认值时,db.Column()都会调用指定的函数 create_time = db.Column(db.DateTime(),default=datetime.utcnow) #最后访问日期 last_seen = db.Column(db.DateTime(),default=datetime.utcnow) def ping(self): """刷新用户最后访问的时间""" self.last_seen = datetime.utcnow() db.session.add(self) # 外键关联 role_id = db.Column(db.Integer(),db.ForeignKey('roles.id')) # 反向引用: 1). User添加属性todos,2).Todo添加属性user todos = db.relationship('Todo',backref='user') # 反向引用: 1). User添加属性category,2).Category添加属性user category = db.relationship('Category',backref='user') def generate_confirmation_token(self,expiration=3600): """生成一个令牌,有效期默认为1小时""" s = TimedJSONWebSignatureSerializer(current_app.config['SECRET_KEY'],expiration) return s.dumps({'confirm': self.id}) def confirm(self,token): """检验令牌和检查令牌中的id和已登录用户id是否匹配?如果通过检验,则把新添加的confirmed属性设置为True""" s = TimedJSONWebSignatureSerializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except Exception as e: return False if data.get('confirm') != self.id: return False self.confirmed = True db.session.add(self) db.session.commit() return True def __repr__(self): return "<User: %s>" %(self.username) @property def password(self): raise AttributeError('password is not a readable attribute') @password.setter def password(self,password): # generate_password_hash(password, method= pbkdf2:sha1 , salt_length=8):密码加密的散列值。 self.password_hash = generate_password_hash(password) def verify_password(self,password): # check_password_hash(hash, password) :密码散列值和用户输入的密码是否匹配. return check_password_hash(self.password_hash,password)
class Journal(db.Model): __tablename__ = 'journals' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(200)) content = db.Column(db.String()) category_id = db.Column(db.Integer, db.ForeignKey('journal_categories.id')) category = db.relationship("JournalCategory") created_user_id = db.Column(db.Integer, db.ForeignKey('users.id')) created_user = db.relationship( "User", primaryjoin="Journal.created_user_id == User.id") last_edited_user_id = db.Column(db.Integer, db.ForeignKey('users.id')) last_edited_user = db.relationship( "User", primaryjoin="Journal.last_edited_user_id == User.id") post_time = db.Column(db.DateTime) last_edited_time = db.Column(db.DateTime) is_activated = db.Column(db.SmallInteger, default=1) comment_topic_id = db.Column(db.Integer, db.ForeignKey('comment_topics.id')) comment_topic = db.relationship("CommentTopic") journal_contents = db.relationship("JournalContent", back_populates="journal") def __init__(self, title, content, created_user, category, is_activated=1): self.title = title self.content = content self.created_user = created_user self.is_activated = is_activated self.category = category self.post_time = datetime.datetime.now() self.comment_topic = sketchup.CommentTopic( gettext('Comments for journal title ') + self.title, self.created_user, 'journal') def to_dict(self, include_category=False, include_created_user=False, include_last_edited_user=False): category = None if include_category: category = self.category.to_dict() created_user = None if include_created_user: created_user = self.created_user.to_dict() last_edited_user = None if include_last_edited_user: if self.last_edited_user is not None: last_edited_user = self.last_edited_user.to_dict() return { 'id': self.id, 'title': self.title, 'content': self.content, 'is_activated': self.is_activated, 'category': category, 'created_user': created_user, 'post_time': self.post_time, 'last_edited_user': last_edited_user, 'last_edited_time': self.last_edited_time } def get_journal_content(self, locale=config.BABEL_DEFAULT_LOCALE): for journal_content in self.journal_contents: if journal_content.locale == locale: return journal_content def __repr__(self): return '<Journal %r>' % (self.title)
tags = [] for text in set(texts): tag = Tag.query.filter_by(text=text).first() if not tag: tag = Tag(text=text) db.session.add(tag) tags.append(tag) return tags def __repr__(self): return f"<Tag {self.id} {self.text}>" tagged_snippets = db.Table( "tagged_snippets", db.Column("snippet_id", db.Integer, db.ForeignKey("snippets.id")), db.Column("tag_id", db.Integer, db.ForeignKey("tags.id")), ) class Snippet(db.Model): __tablename__ = "snippets" __table_args__ = (db.Index("iso_week_date", "year", "week"), ) id = db.Column(db.Integer, primary_key=True, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) text = db.Column(db.UnicodeText, nullable=False) year = db.Column(db.Integer, nullable=False) week = db.Column(db.Integer, nullable=False) tags = db.relationship( "Tag", secondary=tagged_snippets,
class Follow(db.Model): __tablename__ = 'follows' follower_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True) followed_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True) timestamp = db.Column(db.DateTime, default=datetime.utcnow)
class Config(db.Model): id = db.Column(db.String(36), primary_key=True) uid = db.Column(db.String(36), db.ForeignKey('user.id'), nullable=False) theme = db.Column(db.String(20), default='darkly')
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) role_id = db.Column(db.Integer, db.ForeignKey('roles.id')) password_hash = db.Column(db.String(128)) confirmed = db.Column(db.Boolean, default=False) 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) posts = db.relationship('Post', backref='author', lazy='dynamic') 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') comments = db.relationship('Comment', backref='author', lazy='dynamic') def __init__(self, **kwargs): # 定义默认的用户角色 super(User, self).__init__(**kwargs) if self.role is None: if self.email == current_app.config['FLASKY_ADMIN']: self.role = Role.query.filter_by(permissions=0xff).first() if self.role is None: self.role = Role.query.filter_by(default=True).first() # self.follow(self) # 构建用户时把用户设为自己的关注者 @property # 在user模型中加入密码散列 def password(self): raise ArithmeticError('password is not a readable attributes') @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) def generate_confirmation_token(self, expiration=3600): s = Serializer(current_app.config['SECRET_KEY']) return s.dumps({'confirm': self.id}) def confirm(self, token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return False if data.get('confirm') != self.id: return False self.confirmed = True db.session.add(self) return True def generate_reset_token(self, expiration=3600): s = Serializer(current_app.config['SECRET_KEY'], expiration) return s.dumps({'reset': self.id}) def reset_password(self, token, new_password): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return False if data.get('reset') != self.id: return False db.session.add(self) return True def generate_email_change_token(self, new_email, expiration=3600): s = Serializer(current_app.config['SECRET_KEY'], expiration) return s.dumps({'change_email': self.id, 'new_email': new_email}) def change_email(self, token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return False if data.get('change_email') != self.id: return False new_email = data.get('new_email') if new_email is None: return False if self.query.filter_by(email=new_email).first() is not None: return False return True def can(self, permissions): # 检查用户是否有指定的权限 return self.role is not None and \ (self.role.permissions and permissions) == permissions def is_administrator(self): # 检查用户是否有指定的权限 return self.can(Permission.ADMINISTER) def ping(self): # 刷新用户的最后访问时间 self.last_seen = datetime.utcnow() db.session.add(self) def follow(self, user): # 关注关系的辅助方法 if not self.is_following(user): f = Follow(follower=self, followed=user) db.session.add(f) def unfollow(self, user): f = self.followed.filter_by(followed_id=user.id).first() if f: db.session.delete(f) 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): return Post.query.join(Follow, Follow.followed_id == Post.author_id) \ .filter(Follow.follower_id == self.id) def to_json(self): # 把用户转换成JSON格式的序列化字典 json_user = { 'url': url_for('api.get_post', id=self.id, _external=True), 'username': self.username, 'member_since': self.member_since, 'last_seen': self.last_seen, 'posts': url_for('api.get_user.posts', id=self.id, _external=True), 'followed_posts': url_for('api.get_user_followed_posts', id=self.id, _external=True), 'post_count': self.posts.count() } return json_user def generate_auth_token(self, expiration): # 支持基于令牌的认证 s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'id': self.d}).decode('ascii') @staticmethod def verify_auth_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return None return User.query.get(data['id']) def __repr__(self): return '<User %r>' % self.username
from app import db from datetime import datetime from flask_login import UserMixin from app import login from werkzeug.security import generate_password_hash, check_password_hash from hashlib import md5 from time import time import jwt from app import app followers = db.Table( 'followers', db.Column('follower_id', db.Integer, db.ForeignKey('user.id')), db.Column('followed_id', db.Integer, db.ForeignKey('user.id'))) @login.user_loader def load_user(id): return User.query.get(int(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,
class Task(db.Model): id = db.Column(db.Integer, primary_key=True) survey_id = db.Column(db.Integer, db.ForeignKey('survey.id')) assignments = db.relationship('Assignment', backref='task', lazy='dynamic')