class NCBIMail(db.Model):
__tablename__ = 'ncbi_mails'
id = db.Column(db.Integer, primary_key=True)
publication_id = db.Column(db.String(50))
ncbi_publication_url = db.Column(db.String(150))
email = db.Column(db.String(100), unique=True)
package_id = db.Column(db.Integer, db.ForeignKey('ncbi_mail_packages.id'))
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
def __repr__(self):
return f"<NCBIMail: {self.email}>"
class Suggestion(db.Model):
title = db.Column(db.Text)
text = db.Column(db.Text)
first_name = db.Column(db.Text)
id = db.Column(db.Integer, primary_key=True)
status_flagged = db.Column(db.Boolean, default=False)
status_reviewed = db.Column(db.Boolean, default=False)
status_visible = db.Column(db.Boolean)
view_count = db.Column(db.Integer)
dt = db.Column(db.DateTime, default=datetime.datetime.now)
def __init__(self, title, text, first_name):
self.title = title
self.text = text
self.first_name = first_name
self.view_count = 0
# TODO: set this as a config variable?
self.status_visible = True
def __repr__(self):
return '<Suggestion %r %r>' % (self.first_name, self.title[:10])
class Task(db.Model):
"""
Model for tasks – everything user has to work on.
All of the tasks are bound by dane before which they must be accomplished although the date isn't fixed.
"""
__tablename__ = 'tasks'
id = db.Column(Integer, primary_key=True)
name = db.Column(String(200), nullable=False)
date = db.Column(Date, nullable=False)
done = db.Column(Boolean)
# priority: Integer for ordering importance of tasks. The base priority value is 0.
priority = db.Column(Integer, nullable=False)
# date_created: saved for future usage
date_created = db.Column(DateTime, nullable=False)
# user_id: nullable for testing and API development version compatibility
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
def __init__(self, name, date, done=False, priority=0):
self.name = name
self.date = date
self.done = done
self.priority = priority
self.date_created = datetime.utcnow()
def __repr__(self):
return '<Task {}: {}>'.format(self.id, self.name)
@staticmethod
def from_form_data(form):
"""
Creates new Task object from given Flask-WTF Form.
:param form: Flask-WTF Form instance
:return: new Task object
"""
return Task(name=form.name.data,
date=form.date.data,
done=form.done.data,
priority=form.priority.data)
@hybrid_property
def date_time(self):
"""
Creates datetime object from given date field and midnight ending this date
:return: datetime object equivalent to this date
"""
return datetime.combine(self.date, datetime.max.time())
class Learner(db.Model):
"""
Create Learner table
"""
__tablename__ = 'learners'
id = db.Column(db.Integer, primary_key=True)
name = Column(String(64), unique=True, nullable=True)
email = Column(String(64), index=True ,nullable=False, unique=True)
screenname = Column(String(64), default=None, nullable=True, unique=True)
password = Column(String(200), nullable=False)
favourites = db.relationship('Worksheet', secondary=worksheets_identifier, lazy='subquery',
backref=db.backref('learners', lazy=True))
def __repr__(self):
return '<Learner %r>' % self.name
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
poster = db.Column(db.String(80))
datetime = db.Column(db.DateTime)
droptime = db.Column(db.DateTime)
location = db.Column(db.String(160))
groceries = db.Column(db.String)
cost = db.Column(db.String(80))
priority = db.Column(db.Integer)
replies = db.Column(db.String)
def __init__(self, payload):
for k in cols:
if k in ('id', 'replies'):
continue
if payload.get(k):
if k == 'groceries':
setattr(self, k, json.dumps(payload[k]))
else:
setattr(self, k, payload[k])
def __repr__(self):
return "<Post: {}>".format(self.email)
def to_dict(self):
d = {}
for k in cols:
val = getattr(self, k)
if val:
if k in ('groceries', 'replies'):
d[k] = json.loads(val)
else:
d[k] = val
return d
class Player(PkModel):
"""A role for a user."""
__tablename__ = "player"
id = Column(db.Integer, primary_key=True)
name = Column(db.String(80))
username = Column(db.String(80))
rating = Column(db.Integer)
team_id = db.Column(db.Integer, db.ForeignKey('team.id'), nullable=False)
def __init__(self, **kwargs):
"""Create instance."""
super().__init__(**kwargs)
def __repr__(self):
"""Represent instance as a unique string."""
return f"<Player({self.name})>"
class Order(db.Model):
__tablename__ = 'orders'
order_id = db.Column(db.String(50), nullable=False, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
currency = db.Column(db.String(10), nullable=False)
price_paid = db.Column(db.Float(20), nullable=False)
email = db.Column(db.String(255), nullable=False)
timestamp = db.Column(db.String(50), default=str(datetime.now())[:-7])
checkout_id = db.Column(db.String(100), nullable=False)
status = db.Column(db.String(50), default='Paid', nullable=False)
shipping = db.relationship('Shipping', backref='/shipping', lazy=True)
def as_dict(self):
''' return as dict // this is needed for when I do a fetch request with json '''
return {c.name: str(getattr(self, c.name)) for c in self.__table__.columns}
def create_order(self):
db.session.add(self)
db.session.commit()
def custom_query(self, query, value):
''' custom user query. Pass through query, and value . example username:Ian '''
return self.query.filter_by(**{query:value})
def update_status(self, order_id):
result = self.custom_query('order_id', order_id).first()
if not result:
return False
result.status = 'Fulfilled'
db.session.commit()
return True
@staticmethod
def generate_order(length=6):
''' generate order ID until an ID is generated that doesn't already exist'''
generate = string.ascii_uppercase + string.ascii_uppercase + string.digits
returned_id = ''.join(choice(generate) for i in range(length))
while(Order().custom_query('order_id', returned_id).first()):
generate = string.ascii_uppercase + string.ascii_uppercase + string.digits
return returned_id
class Text(db.Model):
"""Текст"""
__tablename__ = 'text'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
text = db.Column(db.String, nullable=False)
creation_dt = db.Column(db.DateTime, nullable=False)
last_update_dt = db.Column(db.DateTime)
tags = db.Column(db.String)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
owner = db.relationship('User', back_populates='texts')
class Token(BaseModel):
__tablename__ = 'token'
access_token = db.Column(db.String(), nullable=False)
token_type = db.Column(db.String(), nullable=False)
scope = db.Column(db.String(), nullable=False)
expires_in = db.Column(db.Integer(), nullable=False)
refresh_token = db.Column(db.String(), nullable=False)
user_id = db.Column(UUIDType(binary=False),
db.ForeignKey('user.id'),
nullable=False,
index=True,
unique=True)
class Calculation(db.Model):
__tablename__ = 'calculations'
id = db.Column(db.Integer, primary_key=True)
module_name = db.Column(db.String(120))
user_data = db.Column(db.Text)
result = db.Column(db.Text)
ip_address = db.Column(db.String(50))
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
def __repr__(self):
return "<Calculation: {} ({})>".format(self.module_name,
self.created_at)
class Customer(UserMixin, db.Model):
__tablename__ = 'customers'
id = db.Column(db.Integer, primary_key=True)
calculations = db.relationship('CustomerCalculation',
backref='customer',
passive_deletes=True)
activity = db.relationship('CustomerActivity',
backref='customer',
passive_deletes=True)
apmc_data = db.relationship('APMCData', backref='customer', lazy='joined')
first_name = db.Column(db.String(120), nullable=True)
last_name = db.Column(db.String(120), nullable=True)
profile_pic = db.Column(db.String(20),
nullable=False,
default='profile.svg')
login = db.Column(db.String(25), unique=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(80))
is_superuser = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
def __repr__(self):
return "<Customer: {} ({})>".format(self.first_name, self.last_name)
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
def to_dict(self):
def convert_datetime(value):
if value:
return value.strftime("%Y-%m-%d %H:%M:%S")
else:
return ""
for col in self.__table__.columns:
if isinstance(col.type, datetime):
value = convert_datetime(getattr(self, col.name))
elif isinstance(col.type, Decimal):
value = float(getattr(self, col.name))
else:
value = getattr(self, col.name, None)
yield (col.name, value)
class Autrag(db.Model, BaseMixin):
__tablename__ = "auftrag"
auftragID = db.Column(db.Integer, primary_key=True)
anr = db.Column(db.Integer)
untersuchungsname = db.Column(db.String)
stemprop = db.Column(db.String)
untersuchung_done = db.Column(db.Boolean, default=False)
listen_id = db.Column(db.Integer, db.ForeignKey("listen.listID"))
def __init__(self, anr, untersuchungsname, stemprop):
self.anr = anr
self.untersuchungsname = untersuchungsname
self.stemprop = stemprop
class City(db.Model):
__tablename__ = "cities"
code_insee = db.Column(db.String(10), primary_key=True, unique=True)
code_postal = db.Column(
db.String(50), primary_key=True
) # Long string because some examples seem to have chained post codes
name = db.Column(db.String(100), primary_key=True)
population = db.Column(db.Float(asdecimal=True))
area = db.Column(db.Float(asdecimal=True))
# Parents
county_code = db.Column(db.ForeignKey('counties.code'))
county = db.relationship('County', foreign_keys=county_code)
class Paper(BaseModel):
__tablename__ = 'paper'
name = db.Column(db.String(255), comment='考试名称')
total_paper_score = db.Column(db.Integer, comment='考卷总分')
exam_time = db.Column(db.Integer, comment='考试时间（分钟）')
remainder_time = db.Column(db.Integer, comment='剩余时间（分钟）')
head_id = db.Column(db.Integer, db.ForeignKey('head.id'),
comment='标题')
head = db.relationship('Head',
backref=db.backref('papers',
lazy='dynamic'))
status = db.Column(db.String(255), comment='状态', default='new')
users = db.relationship('User', secondary=users_papers,
backref=db.backref('papers', lazy='dynamic'))
class User(BaseMixin, db.Model):
__tablename__ = 'users'
userID = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, nullable=False)
_password = db.Column(db.Binary(60))
vorname = db.Column(db.String)
nachname = db.Column(db.String)
email = db.Column(db.String, nullable=False)
is_admin = db.Column(db.Boolean, default=False)
is_active = db.Column(db.Boolean, default=True)
def __init__(self, username, password, email):
self.username = username
self.password = self._hash_pw(password).encode('utf-8')
self.email = self.email
def _hash_pw(self, password):
return bcrypt.hash_pw(password, bcrypt.gensalt(12))
def check_pw(self, password, hashed_pw):
return bcrypt.check_pw(password, hashed_pw)
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
def json(self):
return {
"id": str(self.id),
"username": self.username,
"vorname": self.vorname,
"nachname": self.nachname,
"email": self.email,
"is_admin": self.is_admin
}
class SystemSetting(db.Model, BaseMixin):
__tablename__ = "systemSettings"
sys_email = db.Column(db.String(60))
sys_email_pw = db.Column(db.String(60))
sys_email_host = db.Column(db.String(60))
sys_email_port = db.Column(db.Integer)
sys_email_tls = db.Column(db.Boolean)
kaffee_preis = db.Column(db.Float)
def __init__(self, kaffee_preis):
self.kaffee_preis = kaffee_preis
@classmethod
def get_settings(cls):
return cls.query.get(1)
class Waiting(db.Model):
__tablename__ = "waitings"
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.Integer)
name = db.Column(db.String(300), nullable=True)
n = db.Column(db.Boolean)
office_id = db.Column(db.Integer, db.ForeignKey('offices.id'))
task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'))
def __init__(self, number, office_id, task_id, name=None, n=False):
self.number = number
self.office_id = office_id
self.task_id = task_id
self.name = name
self.n = n
class Orders(db.Model):
"""Таблица с заказами."""
__orders__ = "orders"
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
comment="ID заказа")
address_from = db.Column(db.String,
nullable=False,
comment="Адрес отправления")
address_to = db.Column(db.String,
nullable=False,
comment="Адрес назначения")
client_id = db.Column(db.Integer,
ForeignKey("clients.id"),
nullable=False,
comment="ID клиента")
driver_id = db.Column(db.Integer,
ForeignKey('drivers.id', ondelete='CASCADE'),
nullable=False,
comment="ID водителя")
client_id = db.Column(db.Integer,
ForeignKey('clients.id', ondelete='CASCADE'),
nullable=False,
comment="ID клиента")
date_created = db.Column(
db.String,
nullable=False,
default=datetime.now(),
comment="Время создания заказа",
)
status = db.Column(db.String, nullable=False, comment="Статус заказа")
def __init__(self, *args, **kwargs):
"""Конструктор."""
super(Orders, self).__init__(*args, **kwargs)
class User(db.Model):
"""Class: User."""
__tablename__ = 'user'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String, nullable=False)
last_name = db.Column(db.String)
email_id = db.Column(db.String, nullable=False, index=True)
phone_number = db.Column(db.Integer, nullable=False, index=True)
createdDateTime = db.Column(db.DateTime, default=datetime.datetime.now)
updatedDateTime = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
def save(self):
db.session.begin(subtransactions=True)
db.session.add(self)
db.session.commit()
class Words(db.Model):
__tablename__ = 'words'
__table_args__ = (
db.UniqueConstraint("view_id", "word"),
)
id = db.Column(db.Integer, primary_key=True)
word = db.Column(db.String(255), nullable=False)
translation = db.Column(db.String(255), nullable=False)
url = db.Column(db.String(511), nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
category_id = db.Column(db.Integer, db.ForeignKey('category.id', ondelete='CASCADE'), nullable=False)
category = db.relationship('Category', backref=db.backref('words', lazy=True))
view_id = db.Column(db.Integer, db.ForeignKey('view.id', ondelete='CASCADE'), nullable=False)
view = db.relationship('View', backref=db.backref('views', lazy=True))
def __repr__(self):
return '<Words %r>' % self.word
class MetaDataDB(db.Model):
__tablename__ = "packages"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
publisher = db.Column(db.String(64), unique=True)
descriptor = db.Column(db.JSON)
status = db.Column(db.String(16))
private = db.Column(db.Boolean)
def __init__(self, name, publisher, descriptor, status, private):
self.name = name
self.publisher = publisher
self.descriptor = descriptor
self.status = status
self.private = private
class Project(Base):
STATUS_CHOICE = [
('in_progress', 'In Progress'),
('completed', 'Completed')
]
start_date = db.Column(db.Date)
end_date = db.Column(db.Date)
status = db.Column(ChoiceType(STATUS_CHOICE), nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('user.id'))
org_id = db.Column(db.Integer, db.ForeignKey('organisation.id'))
contact_id = db.Column(db.Integer, db.ForeignKey('contact.id'))
activities = db.relationship('Activity', backref='project')
invoices = db.relationship('Invoice', backref='project')
class TestPlan(db.Model):
__tablename__ = 'test_plan'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(180), unique=False)
comment = db.Column(db.String(300), unique=False)
status = db.Column(db.String(20), unique=False)
test_case = db.relationship("TestCase",
backref="test_plan",
lazy="dynamic")
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __repr__(self):
return '%r' % (self.name)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, nullable=False)
password = db.Column(db.Text, nullable=False)
permission = db.Column(db.Integer,
default=constant.PERMISSION_NOMAL,
nullable=False)
twitter_user_id = db.Column(db.Text)
create_at = db.Column(db.DateTime, default=datetime.now, nullable=False)
update_at = db.Column(db.DateTime, default=datetime.now, nullable=False)
tweets = db.relationship("Tweet", backref="tweets")
bots = db.relationship("Bot", backref="bots")
@classmethod
def create(cls, name, password, permission=3, twitter_user_id=None):
user = cls(name=name,
password=generate_password_hash(password),
permission=permission,
twitter_user_id=twitter_user_id)
db.session.add(user)
db.session.flush()
return user
@classmethod
def get_all(cls):
return db.session.query(cls).all()
def update(self,
name=None,
password=None,
permission=None,
twitter_user_id=None):
if name:
self.name = name
if password:
self.password = generate_password_hash(password)
if permission:
self.permission = permission
if twitter_user_id:
self.twitter_user_id = twitter_user_id
class User(db.Model, UserMixin):
"""
Модель пользователей
"""
__tablename__ = 'users'
id = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True,
comment='ID пользователя')
name = db.Column(db.String(255),
nullable=False,
comment='Имя пользователя')
phone = db.Column(db.String(255),
nullable=False,
comment='Телефон пользователя')
email = db.Column(db.String(255),
nullable=False,
unique=True,
comment='Email пользователя')
password = db.Column(db.String(255),
nullable=False,
comment='Пароль пользователя')
created_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.now(),
comment='Дата создания')
updated_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.now(),
comment='Дата обновления')
confirmed = db.Column(db.Boolean(), default=False, comment='Подтвержден?')
def __repr__(self):
return '<User %r>' % self.name
class BugFix(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(1023))
text = db.Column(db.Text)
date = db.Column(db.Date)
status = db.Column(db.String(1))
timefj = db.Column(db.Time)
createdate = db.Column(db.DateTime, default=db.func.now())
def __repr__(self):
return self.id
def to_dict(self):
return {
'name': self.name,
'text': self.text,
'date': str(self.date),
'status': self.status,
'createdate': str(self.createdate)
}
class House(db.Model):
id = db.Column(db.Integer, primary_key=True)
HouseName = db.Column(db.String(64),
index=True,
unique=True,
nullable=False)
HousePoints = db.Column(db.Integer)
Students = db.relationship('Student', backref='house', lazy=True)
BlueRecycled = db.Column(db.Integer)
BrownRecycled = db.Column(db.Integer)
OrangeRecycled = db.Column(db.Integer)
TotalRecycled = db.Column(db.Integer)
def __repr__(self):
return f'<House {self.HouseName}>'
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class User(db.Model):
__tablename__ = "users"
id = db.Column(
INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
)
uuid = db.Column(db.String(28), nullable=False)
name = db.Column(db.String(255), nullable=False)
level = db.Column(INTEGER(unsigned=True), default=0)
title = db.Column(db.Text, nullable=False)
done_cnt = db.Column(INTEGER(unsigned=True), default=0)
created_at = db.Column(
db.DateTime,
server_default=db.func.current_timestamp(),
server_onupdate=db.func.current_timestamp(),
nullable=False,
)
updated_at = db.Column(
db.DateTime,
server_default=db.func.current_timestamp(),
server_onupdate=db.func.current_timestamp(),
nullable=False,
)
quests = db.relationship("Quest", backref="user", cascade="all")
def __init__(self, uuid, name):
self.uuid = uuid
self.name = name
self.title = ""
def to_dict(self):
return dict(
name=self.name,
title=self.title,
)
class Product(db.Model):
__tablename__ = 'products'
store_name = db.Column(db.String(200), nullable=False)
product_id = db.Column(db.Integer, primary_key=True)
item_name = db.Column(db.String(255), nullable=False)
item_desc = db.Column(db.TEXT(500), nullable=False)
item_currency = db.Column(db.String(50), nullable=False)
item_price = db.Column(db.String(20), nullable=False)
image = db.Column(db.String(200), nullable=False)
contact_email = db.Column(db.String(255), nullable=False)
product_link = db.relationship('User', backref="product", secondary=user_product)
def create_product(self):
db.session.add(self)
db.session.commit()
return self
def update(self):
query = self.custom_query('product_id', self.product_id).first()
for att in ('store_name', 'item_name', 'item_desc', 'item_currency', 'item_price', 'contact_email'):
setattr(query, att, getattr(self, att))
if "<FileStorage: ''" not in str(self.image):
Uploads.remove_upload(query.image)
query.image = Uploads(self.image).save_upload()
db.session.commit()
def custom_query(self, query, value):
return self.query.filter_by(**{query:value})
@staticmethod
def appendTable(user, product):
user.product.append(product)
db.session.commit()
