class Menu(db.Model):
__tablename__ = 'Menu'
menu_id = db.Column(db.Integer, primary_key=True)
hotel_id = db.Column(db.Integer)
item_name = db.Column(db.String(255))
item_id = db.Column(db.Integer)
item_price = db.Column(db.Float)
item_type = db.Column(db.String(225))
item_status = db.Column(db.Boolean)
def __init__(self, hotel_id, item_name, item_id, item_price, item_type,
item_status):
self.hotel_id = hotel_id
self.item_name = item_name
self.item_id = item_id
self.item_price = item_price
self.item_type = item_type
self.item_status = item_status
class User(db.Model): # notice that our class extends db.Model
__tablename__ = 'userregister' # this is the name we want the table in database to have.
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(20), unique=False, nullable=False)
lastname = db.Column(db.String(20), unique=False, nullable=False)
dob = db.Column(db.String(20), unique=False, nullable=True)
address = db.Column(db.String(50), unique=True, nullable=False)
NIN = db.Column(db.String(100), unique=False, nullable=False)
# represent the object when it is queried for
def __repr__(self):
return '<Register {}>'.format(self.id)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class Post(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(60), nullable=False)
date = db.Column(db.Date, nullable=False, default=datetime.utcnow)
time = db.Column(db.Time, nullable=False, default=datetime.now().time())
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
def __repr__(self):
return f"Post('{self.title}','{self.date}','{self.time}')"
class Book(db.Model):
__tablename__ = "books"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String())
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def __repr__(self):
return f"<Book {self.title}>"
class Product(CreatorModelBase, TimeStampModelBase, BaseModel):
name = db.Column(db.String(250))
description = db.Column(db.String(250))
amount_min = db.Column(db.Integer)
amount_total = db.Column(db.Integer)
''' shopping = db.relationship('Shopping', backref='product')
score = db.relationship('Score', backref='product')
output = db.relationship('Output', backref='product')'''
def __init__(self, name, description, amount_min, amount_total, created_by):
self.name = name
self.description = description
self.amount_min = amount_min
self.amount_total = amount_total
self.created_by = created_by
def __repr__(self):
return f"<{self.__name__} {self.name}>"
class ZqsbNews(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(1024))
master_id = db.Column(db.Integer, db.ForeignKey('zqsb.id'))
master = db.relationship('Zqsb', back_populates='news')
class User(db.Model):
email = db.Column(db.String(64), primary_key=True)
name = db.Column(db.String(64), nullable=False)
password = db.Column(db.String(64), nullable=False)
bank_account = db.Column(db.String(64), nullable=False)
phone = db.Column(db.Integer, nullable=False)
address = db.Column(db.String(64), nullable=False)
@property
def json(self):
return {
k: getattr(self, k).json
if hasattr(getattr(self, k), 'json') else getattr(self, k)
for k in [
k for k in dir(self) if k[0] != '_'
and k not in {'json', 'metadata', 'query', 'query_class'}
]
}
class User(UserMixin, db.Model):
#__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
email = db.Column(db.String(120), unique=True)
password_hash = db.Column(db.String(128))
# this function defines what will happen with we try and print the object
def __repr__(self):
return '<User {}>'.format(self.username)
# using the werkeug module to create a password hash from a password
def set_password(self, password):
self.password_hash = generate_password_hash(password)
# cheking if teh hash matches a password (BOOL)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class ExternalEvent(BaseModel):
_tablename_ = "external_event"
primary_event = db.Column(db.Boolean, default=False)
platform_id = db.Column(db.Integer, db.ForeignKey('platform.id'))
event_id = db.Column(db.Integer, db.ForeignKey('event.id'))
ext_event_id = db.Column(db.String(100))
ext_event_url = db.Column(db.String(300))
sync_date = db.Column(db.DateTime, nullable=True, default=None)
def updateSyncDate(self):
self.sync_date = datetime.utcnow()
db.session.add(self)
db.session.commit()
def platformName(self):
return Platform.query.get(self.platform_id).name
class Utilisateurs(db.Model):
id = db.Column(db.Integer, primary_key=True)
nom = db.Column(db.String(50), nullable=False)
prenom = db.Column(db.String(50), nullable=False)
date_naissance = db.Column(db.DateTime, nullable=False)
def __init__(self, nom, prenom, date_naissance):
self.nom = nom
self.prenom = prenom
self.date_naissance = date_naissance
@property
def serialize(self):
return {
'nom': self.nom,
'prenom': self.prenom,
'date_naissance': self.date_naissance
}
class User(db.Model):
userid = db.Column(db.Integer, primary_key=True)
userfirstname = db.Column(db.String(20))
userlastname = db.Column(db.String(20))
userphone = db.Column(db.Integer)
username = db.Column(db.String(20), unique=True)
userpass = db.Column(db.String(20))
email = db.Column(db.String(50), unique=True)
def __init__(self, userid, userfirstname, userlastname, userphone,
username, userpass, email):
self.userlastname = userlastname
self.username = username
self.email = email
self.userid = userid
self.userphone = userphone
self.userpass = userpass
self.userfirstname = userfirstname
class Notification(db.Model):
id = db.Column(db.Integer, primary_key=True)
senderId = db.Column(db.Integer, db.ForeignKey('user.id'))
receiverId = db.Column(db.Integer, db.ForeignKey('user.id'))
message = db.Column(db.String())
time = db.Column(db.DateTime, index=True, default=datetime.utcnow())
def __repr__(self):
return 'Notification {}'.format(self.message)
class Knowledge(db.Model):
__tablename__ = "knowledge"
knowledge_id = db.Column(db.Integer, primary_key=True)
knowledge = db.Column(db.String(1000), nullable=False)
def __init__(self, knowledge):
self.knowledge = knowledge
class PostImage(db.Model):
__tablename__ = "post_images"
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(), nullable=False, unique=True)
post_id = db.Column(db.Integer, db.ForeignKey("posts.id"), nullable=False)
def __repr__(self):
return f"<PostImage {self.id}>"
class User(db.Model,UserMixin):
id=db.Column(db.Integer,primary_key=True)
username=db.Column(db.String(20),unique=True,nullable=False)
email=db.Column(db.String(30),unique=True,nullable=False)
phonenumber=db.Column(db.String(30),unique=True,nullable=False)
password=db.Column(db.String(80),nullable=False)
code=db.Column(db.String(10),nullable=True)
def get_login_token(self,expiretime=120):
s=serializer(app.config['SECRET_KEY'],expiretime)
return s.dumps({"user_id":self.id}).decode("utf-8")
@staticmethod
def check_token(token):
s=serializer(app.config['SECRET_KEY'])
try:
user_id=s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) #relationship here we are ref the table name and column name
def __repr__(self):
return f"Post('{self.title}', {self.date_posted}')"
class User(UserMixin, db.Model):
""" 用户实体 """
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(256), unique=True, nullable=False)
password_hash = db.Column(db.String(128))
avatar_url = db.Column(db.String(256))
messages = db.relationship('Message',
back_populates='author',
cascade='all')
dndcard = db.relationship('DndCard',
back_populates='author',
cascade='all')
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.username is not None and self.avatar_url is None:
self.avatar_url = 'https://gravatar.com/avatar/' + hashlib.md5(self.username.encode('utf-8')).hexdigest() + \
'?d=identicon'
class Error(db.Model):
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.String(10000))
time = db.Column(db.DateTime())
type = db.Column(db.String(100))
user_agent = db.Column(db.String(500))
project_name = db.Column(db.String(120))
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'id': self.id,
'message': self.message,
'time': self.time.isoformat(),
'type': self.type,
'user_agent': self.user_agent,
}
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
def __init__(self, name):
self.name = name
def __repr__(self):
return '<Category {}'.format(self.id)
class Image(db.Model):
image_file = db.Column(db.String(20),
primary_key=True,
nullable=False,
default='default.jpg')
def __repr__(self):
return f"Image('{self.image_file})"
class Standards(db.Model):
__tablename__ = "standards"
id = db.Column(db.Integer, primary_key=True)
standard = db.Column(db.String(200), nullable=False)
section_list = db.Column(db.String(200), nullable=True)
def __repr__(self):
return '{"id":{0}, "standard":{1}}'.format(self.id, self.standard)
@classmethod
def get_all_standards(cls):
standards = Standards.query.all()
standards_json = [standard.serialize() for standard in standards]
return standards_json
@classmethod
def get_standard_from_id(cls, id):
standard = cls.query.get(id)
return standard
@classmethod
def delete_standard_from_id(cls, id):
standard = cls.get_standard_from_id(id)
if standard is None:
return None
db.session.delete(standard)
db.session.commit()
return standard
@classmethod
def submit_standard_from_json(cls, json_standard):
standard = cls(standard=json_standard['standard'])
db.session.add(standard)
db.session.commit()
return standard
# todo:json encoding needed
def serialize(self):
json_standard = {
'id': self.id,
'standard': self.standard,
'section_list': self.section_list
}
return json_standard
class DrugExposure(db.Model):
__tablename__ = 'drug_exposure'
drug_exposure_id = db.Column(db.Integer, primary_key=True)
person_id = db.Column(db.Integer,
db.ForeignKey('person.person_id',
ondelete='CASCADE'),
nullable=False)
drug_concept_id = db.Column(db.Integer,
db.ForeignKey('concept.concept_id',
ondelete='CASCADE'),
nullable=True)
drug_exposure_start_datetime = db.Column(db.DateTime, nullable=True)
drug_exposure_end_datetime = db.Column(db.DateTime, nullable=True)
visit_occurrence_id = db.Column(db.Integer,
db.ForeignKey(
'visit_occurrence.visit_occurrence_id',
ondelete='CASCADE'),
nullable=False)
drug_exposure_start_date = db.Column(db.Date, nullable=False)
drug_exposure_end_date = db.Column(db.Date, nullable=False)
verbatim_end_date = db.Column(db.Date, nullable=True)
drug_type_concept_id = db.Column(db.Integer,
db.ForeignKey('concept.concept_id',
ondelete='CASCADE'),
nullable=True)
stop_reason = db.Column(db.String(64), nullable=True)
refills = db.Column(db.Integer, nullable=False)
quantity = db.Column(db.Integer, nullable=False)
days_supply = db.Column(db.Integer, nullable=False)
sig = db.Column(db.String(64), nullable=True)
route_concept_id = db.Column(db.Integer,
db.ForeignKey('concept.concept_id',
ondelete='CASCADE'),
nullable=True)
lot_number = db.Column(db.Integer, nullable=False)
provider_id = db.Column(db.Integer, nullable=False)
drug_source_value = db.Column(db.String(32), nullable=False)
drug_source_concept_id = db.Column(db.Integer,
db.ForeignKey('concept.concept_id',
ondelete='CASCADE'),
nullable=True)
route_source_value = db.Column(db.String(64), nullable=True)
does_unit_source_value = db.Column(db.String(64), nullable=True)
visit_detail_id = db.Column(db.Integer, nullable=True)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
u_name = db.Column(db.String(32))
u_surname = db.Column(db.String(32))
u_phone = db.Column(db.String(32), nullable=False)
u_password = db.Column(db.String(64), nullable=False)
u_src = db.Column(db.String(128))
u_city = db.Column(db.String(32))
u_age = db.Column(db.Integer)
u_about = db.Column(db.String(140))
u_gender = db.Column(db.String(6))
class ClassModel(db.Model):
__tablename__ = 'classes'
p_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
code = db.Column(db.String(120), unique=True, nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def db_to_delete(self):
db.session.delete(self)
db.session.commit()
def db_to_commit(self):
db.session.commit()
#FOR CONVERT DATA INTO JSON FORMAT
@staticmethod
def to_json(data):
return {
'name': data.name,
'code': data.code,
}
@classmethod
def find_by_code(cls, code):
return cls.query.filter_by(code=code).first()
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
@classmethod
def find_by_id(cls, p_id):
return cls.query.filter_by(p_id=p_id).first()
@classmethod
def return_all(cls):
return {
'classes':
list(map(lambda x: cls.to_json(x), ClassModel.query.all()))
}
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
fullName = db.Column(db.String(120), unique=False, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def return_all(cls):
def to_json(x):
return {
'fullName': x.fullName,
'email': x.email,
'password': x.password
}
return {
'users': list(map(lambda x: to_json(x), UserModel.query.all()))
}
@classmethod
def delete_all(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': '{} row(s) deleted'.format(num_rows_deleted)}
except:
return {'message': 'Something went wrong'}
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
class SNKRSList(db.Model):
id = db.Column(db.Integer, primary_key=True)
Site = db.Column(db.String(20), nullable=False)
Brand = db.Column(db.String(20), nullable=False)
Region = db.Column(db.String(20), nullable=False)
Name = db.Column(db.String(20), nullable=False)
StyleCode = db.Column(db.String(20), nullable=False)
ColorWay = db.Column(db.String(20), nullable=False)
LDate = db.Column(db.Date, nullable=True)
LTime = db.Column(db.Time, nullable=True)
Img = db.Column(db.String(200), nullable=False)
Url = db.Column(db.String(200), nullable=False)
Price = db.Column(db.Integer, nullable=False)
Currency = db.Column(db.String(20), nullable=True)
RestockWatch = db.Column(db.Boolean)
class ABExperiment(db.Model):
__tablename__ = "experiment"
# unique constraint on multiple fields:
__table_args__ = (db.UniqueConstraint('app_id', 'name', name="unique_constraint_app_exp"), )
id = db.Column(db.Integer, primary_key=True)
app_id = db.Column(db.Integer, db.ForeignKey("app.id"))
name = db.Column(db.String(120), index=True)
description = db.Column(db.Text)
metrics = db.Column(db.Text)
start_date = db.Column(db.Date)
end_date = db.Column(db.Date)
options = db.relationship('ABOption', backref='experiment') # cascade="all, delete-orphan"
@property
def metrics_json(self):
return json.loads(self.metrics) if self.metrics is not None else dict()
@property
def clean_name(self):
clean_name = " ".join(
[i.capitalize() for i in self.name.split("_") if i not in ("exp", "ios", "android")]
)
return clean_name
@property
def sorted_options(self):
options = sorted(self.options, key=lambda x: (-x.is_control_group, x.name))
return [i.name for i in options]
def is_period_data_exists(self, period):
""" Chech, wether data exists for requested period (cnt_users > 0 for all options) """
return all([i > 0 for i in self.metrics_json.get(f"cnt_users_{period}").values()])
def get_user_donut_svg_url(self):
return f'img/ab/{self.name}/user_donut.svg'
def get_user_dynamics_svg_url(self):
return f'img/ab/{self.name}/user_dynamics.svg'
def get_pdf_and_confint_svg_url(self, col_name="conversion", period="all"):
return f'img/ab/{self.name}/pdf_{col_name}_{period}.svg'
def get_valueset_total(self, col_name='cnt_users'):
""" Format for further barplot_total, being rendered with chart.js """
if not self.metrics_json:
return
valueset = {i: [] for i in self.sorted_options}
for period in ["1d", "7d", "30d", "all"]:
tmp = self.metrics_json[f"{col_name}_{period}"]
for option in valueset.keys():
valueset[option].append(tmp[option])
return valueset
def __repr__(self):
return f'<Exp: {self.name}>'
class News(db.Model):
id = db.Column(db.Integer, primary_key=True)
header = db.Column(db.String(256), nullable=False)
body = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
active = db.Column(db.Boolean, nullable=False, default=True)
def __init__(self, header, body):
self.header = header
self.body = body
class UsersLogin(db.Model):
__tablename__ = 'users_login'
# _id = db.Column(db.Integer, primary_key=True, unique=True)
emp_id = db.Column(db.Integer, primary_key=True, unique=True)
username = db.Column(db.String(50), nullable=False, unique=True)
password_hash = db.Column(db.String(100), nullable=False)
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
@property
def serialize(self):
return {
'emp_id': self.emp_id,
'username': self.username,
}
@property
def serialize_many2many(self):
"""
Return object's relations in easily serializeable format.
NB! Calls many2many's serialize property.
"""
return [item.serialize for item in self.many2many]
def __init__(self, username, password, emp_id=None):
if emp_id is not None:
self.emp_id = emp_id
self.hash_password(password) # hashing the password
self.username = username
def __repr__(self):
return '<User %r>' % self.emp_id
def get_id(self):
try:
return unicode(self._id) # python 2
except NameError:
return str(self._id) # python 3
