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