class WorkCondition(db.Model):
__tablename__ = 'WorkCondition'
wcond_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
cont_id = db.Column(db.ForeignKey('WorkContract.cont_id',
ondelete='RESTRICT',
onupdate='RESTRICT'),
primary_key=True,
nullable=False,
index=True)
user_id = db.Column(db.Integer, nullable=False, index=True)
wp_id = db.Column(db.Integer, nullable=False)
target_ym = db.Column(db.String(6))
target_date = db.Column(db.String(2))
week_num = db.Column(db.Integer)
day_num = db.Column(db.Integer)
start_time = db.Column(db.Time)
end_time = db.Column(db.Time)
awork_time = db.Column(db.Time)
arest_time = db.Column(db.Time)
hourly_pay = db.Column(db.Integer)
daily_pay = db.Column(db.Integer)
tardy_code = db.Column(db.Integer, nullable=False, server_default='1')
wcond_status = db.Column(db.Integer, nullable=False, server_default='1')
created_time = db.Column(db.DateTime, server_default=func.now())
updated_time = db.Column(db.DateTime)
cont = db.relationship(
'WorkContract',
primaryjoin='WorkCondition.cont_id == WorkContract.cont_id',
backref='work_conditions')
class Daily(db.Model):
__tablename__ = 'Daily'
daily_id = db.Column(db.String(50), primary_key=True, nullable=False)
wcond_id = db.Column(db.Integer, nullable=False)
cont_id = db.Column(db.String(45), nullable=False)
target_ym = db.Column(db.String(6), primary_key=True, nullable=False)
target_date = db.Column(db.String(2), primary_key=True, nullable=False)
week_num = db.Column(db.Integer)
day_num = db.Column(db.Integer)
work_start = db.Column(db.DateTime)
work_end = db.Column(db.DateTime)
act_work_time = db.Column(db.Time)
cont_work_time = db.Column(db.Time)
act_rest_time = db.Column(db.Time)
cont_rest_time = db.Column(db.Time)
over_time = db.Column(db.Time)
night_time = db.Column(db.Time)
holy_time = db.Column(db.Time)
tardy_time = db.Column(db.Time)
act_work_pay = db.Column(db.Integer)
cont_work_pay = db.Column(db.Integer)
over_pay = db.Column(db.Integer)
night_pay = db.Column(db.Integer)
holy_pay = db.Column(db.Integer)
tardy_pay = db.Column(db.Integer)
total_pay = db.Column(db.Integer)
created_time = db.Column(db.DateTime, server_default=func.now())
updated_time = db.Column(db.DateTime)
class ScrapeTask(db.Model):
__tablename__ = "scrape_tasks"
id = db.Column(db.String(36), primary_key=True)
name = db.Column(db.String(128), index=True)
description = db.Column(db.String(128))
candidate_id = db.Column(db.Integer, db.ForeignKey('candidates.id'))
inserted_on = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
updated_on = db.Column(db.DateTime, nullable=True)
complete = db.Column(db.Boolean, default=False)
@property
def progress(self):
return self.get_progress()
def get_rq_job(self):
try:
rq_job = rq.job.Job.fetch(self.id, connection=current_app.redis)
except (redis.exceptions.RedisError, rq.exceptions.NoSuchJobError):
return None
return rq_job
def get_progress(self):
job = self.get_rq_job()
return job.meta.get('progress', 0) if job is not None else 100
class Newsletter(db.Model):
"""
Description of Newsletter Model
Rows
------------------------
:id: int [pk]
:description text
:publish_date: varchar
:newsletter_content: text
:upload_time datetime
:cover_image_url: varchar
"""
id = db.Column(db.Integer, primary_key=True, nullable=False)
description = db.Column(db.Text)
publish_date = db.Column(db.String(255))
newsletter_content = db.Column(db.Text)
upload_time = db.Column(db.DateTime)
cover_image_url = db.Column(db.String(255))
def __init__(self, description, publish_date, newsletter_content,
cover_image_url):
try:
self.description = description
self.publish_date = publish_date
self.newsletter_content = newsletter_content
self.upload_time = convertDateString(publish_date)
self.cover_image_url = cover_image_url
db.session.add(self)
db.session.commit()
LOG.info("New Newsletter Created - {}".format(publish_date))
except BaseException:
LOG.error("Cannot create Newsletter", exc_info=True)
raise BaseException
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key = True)
username = 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_username(cls, username):
return cls.query.filter_by(username = username).first()
@classmethod
def count_user(cls):
return cls.query.count()
@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 StepTransport(Step):
__tablename__ = 'step_transport'
id = db.Column(db.Integer, db.ForeignKey('step.id'), primary_key=True)
end_address_id = db.Column(db.Integer, db.ForeignKey('place.id'))
reservation_number = db.Column(db.String(30))
transport_number = db.Column(db.String(30))
end_address = db.relationship("Place")
__mapper_args__ = {
'polymorphic_identity': StepType.Transport.name,
}
@staticmethod
def from_json(dto, trip_id):
return StepTransport(
name=dto.get('name'),
trip_id=trip_id,
start_datetime=dto.get('start_datetime'),
end_datetime=dto.get('end_datetime'),
start_address=Place.from_json(dto.get('start_address')),
end_address=Place.from_json(dto.get('end_address')),
phone_number=dto.get('phone_number'),
notes=dto.get('notes'),
reservation_number=dto.get('reservation_number'),
transport_number=dto.get('transport_number')
)
class TDataType(db.Model):
"""
数据源对象
"""
__tablename__ = 't_datatype'
id = db.Column(db.Integer, primary_key=True)
cover = db.Column(db.String(150))
name = db.Column(db.String(150), unique=True)
is_disabled = db.Column(db.Integer)
create_time = db.Column(db.DateTime)
update_time = db.Column(db.DateTime)
def json_data(self):
"""
将对象转换为字典数据
:return:s
"""
return {
'id': self.id,
'cover': self.cover,
'name': self.name,
'is_disabled': self.is_disabled,
'create_time': self.create_time,
'update_time': self.update_time
}
def __repr__(self):
return '<tDataType %r>' % self.name
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), unique=True)
mobileNum = db.Column(db.Integer)
password = db.Column(db.String(50))
role = db.Column(db.String(50))
class Debate(db.Model):
"""Pretty much a catch-all table for anything related to a debate at this point."""
__tablename__ = "debates"
id = db.Column(db.Integer, primary_key=True)
views = db.Column(db.Integer)
dtype = db.Column(db.String(40))
topic = db.Column(db.String(100))
current_round_number = db.Column(db.Integer)
stage = db.Column(db.String(10))
max_round_number = db.Column(db.Integer)
max_claim_number = db.Column(db.Integer)
isTimed = db.Column(db.String(10))
time_for_next_phase = db.Column(db.DateTime)
pro_votes = db.Column(db.Integer)
con_votes = db.Column(db.Integer)
definitions = db.relationship("Definition", backref="Debate")
claims = db.relationship("Claim", backref="Debate")
users = db.relationship("UserDebate",
back_populates="debate",
cascade="all, delete-orphan")
users_voted = db.relationship("User",
secondary=user_vote_tally,
back_populates="debates_voted")
has_sent_finished_emails = db.Column(db.Boolean, default=False)
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
public_id = db.Column(db.String(100), unique=True)
username = db.Column(db.String(50), unique=True)
password_hash = db.Column(db.String(100))
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = flask_bcrypt.generate_password_hash(password).decode('utf-8')
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password_hash, password)
def __repr__(self):
return "<User '{}'>".format(self.username)
class Post(db.Model):
__tablename__ = "post"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(200))
content = db.Column(db.String(1000))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class ImageModel(db.Model):
""" Model for storing image related details """
__tablename__ = 'images'
id = db.Column(db.Integer, primary_key=True)
sha256 = db.Column(db.String(64, convert_unicode=True), nullable=False, index=True)
phash = db.Column(db.BigInteger, nullable=False, index=True)
url = db.Column(db.String(255, convert_unicode=True), nullable=False, index=True)
context = db.Column(JSONB(), default=[], nullable=False)
__table_args__ = (
db.Index('ix_images_context', context, postgresql_using='gin'),
)
@staticmethod
def from_url(url, context={}):
"""Fetch an image from a URL and load it
:param url: Image URL
:returns: ImageModel object
"""
remote_request = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
remote_response = urllib.request.urlopen(remote_request)
raw = remote_response.read()
im = Image.open(io.BytesIO(raw)).convert('RGB')
phash = compute_phash_int(im)
sha256 = sha256_stream(io.BytesIO(raw))
return ImageModel(sha256=sha256, phash=phash, url=url, context=context)
class Users(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.String(255), nullable=False)
password_hash = db.Column(db.String(100))
register_on = db.Column(db.DateTime, nullable=False)
last_pass_change = db.Column(db.DateTime, nullable=False)
name = db.Column(db.String(255), nullable=False)
surname = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
country_city_id = db.Column(db.Integer, db.ForeignKey('countries_cities.id'),
nullable=False)
# TODO: Fix the logic about how to do this. Many to many new table is need, isn't?
# technologies = db.relationship('Technologies', backref=db.backref('techs',
# lazy=True))
@property
def password(self):
raise AttributeError("password: write-only field")
@password.setter
def password(self, password):
self.password_hash = flask_bcrypt.generate_password_hash(password).decode('utf-8')
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password_hash, password)
def __repr__ (self):
return f"<Person '{self.name} {self.surname} - {self.email}"
class Menu(db.Model):
__tablename__ = 'sys_menu'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
parent_id = db.Column(db.Integer, comment=u'父菜单')
name = db.Column(db.String(50), comment=u'菜单名称')
icon = db.Column(db.String(50), comment=u'菜单图标')
url = db.Column(db.String(250), comment=u'菜单路径')
order = db.Column(db.SmallInteger, default=0, comment=u'排序')
type = db.Column(db.Integer, comment=u'类型 0：目录 1：菜单 2：按钮')
status = db.Column(db.Integer, default=1, comment=u'状态')
createTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'创建时间')
createBy = db.Column(db.String(50), comment=u'创建人')
updateTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'修改时间')
updateBy = db.Column(db.String(50), comment=u'修改人')
def save(self):
globals.db.add(self)
globals.db.commit()
def update(self):
globals.db.commit()
def delete(self):
globals.db.delete(self)
globals.db.commit()
def __repr__(self):
return '<Menu %r>' % self.name
class UserMetaData(db.Model):
__tablename = "user_metadata"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
value = db.Column(db.String(64), index=True)
key = db.Column(db.String(64), index=True)
user = db.relationship("User", back_populates="user_metadata")
class Category(db.Model):
#creating category table in database
__tablename__= "category"
category_id =db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(50), nullable=False)
category = db.Column(db.String(50), nullable=False)
parent_id = db.Column(db.Integer)
class SupermarketModel(BaseModel):
__tablename__ = 'supermarkets'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False, unique=True)
address = db.Column(db.String(100), nullable=False)
_open_time = db.Column("open_time", db.Integer(), nullable=False)
_close_time = db.Column("close_time", db.Integer(), nullable=False)
@property
def open_time(self):
"""Return open_time value"""
return seconds_to_time(self._open_time)
@open_time.setter
def open_time(self, value):
"""Set open_time value """
self._open_time = time_to_seconds(value)
@property
def close_time(self):
"""Return close_time value"""
return seconds_to_time(self._close_time)
@close_time.setter
def close_time(self, value):
"""Set close_time value"""
self._close_time = time_to_seconds(value)
class SecurityUser(db.Model):
""" storing login/password pairs to provide direct login mechanism"""
__tablename__ = "security_users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(50), unique=True)
password_hash = db.Column(db.String(100))
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False,
unique=True)
user = relationship(User.__name__)
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = flask_bcrypt.generate_password_hash(
password).decode('utf-8')
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password_hash, password)
def __repr__(self):
return f"<Security User {self.username}>"
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.BigInteger, primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.UnicodeText, nullable=False)
first_name = db.Column(db.UnicodeText, nullable=False)
last_name = db.Column(db.UnicodeText, nullable=False)
title = db.Column(db.UnicodeText, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
enabled = db.Column(db.Boolean(),
nullable=False,
default=True,
server_default='1')
@property
def full_name(self):
return ' '.join([self.first_name, self.last_name])
# Required for flask-login
@property
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
class Company(db.Model):
__tablename__ = "COMPANY"
id = db.Column(db.String(32), primary_key=True)
name = db.Column(db.String(256), index=True, unique=True)
link = db.Column(db.String(256), index=True, unique=True)
contents = db.relationship("Content",
secondary=association_table,
back_populates="companies")
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(), unique=True)
public_id = db.Column(db.String(100), unique=True)
def __repr__(self):
return "User: {}".format(self.username)
class Order(db.Model):
# creating order table in the database
__tablename__ = "orders"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
payment_status = db.Column(db.String(50))
status = db.Column(db.String(50))
amount = db.Column(db.Integer)
class ClientModel(BaseModel):
__tablename__ = 'clients'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
dni = db.Column(db.Numeric(8,0), nullable=False)
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
phone = db.Column(db.Integer)
class User(db.Model, UserMixin):
"""
sqlalchemy.exc.InvalidRequestError: Table 'xxx' is already defined for this MetaData instance.
Specify 'extend_existing=True' to redefine options and columns on an existing Table object.
"""
__table_args__ = dict(mysql_charset='utf8', extend_existing=True)
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(100), unique=True, nullable=False)
password_hashed = db.Column(db.String(200), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __init__(self, user_data):
self.username = user_data.get('username')
self.password = user_data.get('password')
self.email = user_data.get('email')
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hashed = bcrypt.generate_password_hash(password).decode(
'utf-8')
def check_password(self, password):
return bcrypt.check_password_hash(self.password_hashed, password)
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def check_login(cls, user_data):
user = User.query.filter_by(username=user_data.get('username')).first()
if user is not None:
if user.check_password(user_data.get('password')):
return user
else:
return False
@classmethod
def find_byID(cls, user_id):
return User.query.get(user_id)
@classmethod
def get_all(cls):
users = [user.__repr__() for user in User.query.all()]
return '[{}]'.format(', '.join(users))
def __repr__(self):
return json.dumps(
dict(
id=self.id,
username=self.username,
password_hashed=self.password_hashed,
email=self.email,
))
class Users(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password_hash = db.Column(db.String(100))
photo_url = db.Column(db.String(255))
# created = db.Column(
# db.DateTime, nullable=False, default=datetime.datetime.now()
# )
# created_by = db.Column(db.Integer, nullable=False)
# last_modified = db.Column(
# db.DateTime,
# nullable=False,
# default=datetime.datetime.now(),
# onupdate=datetime.datetime.now()
# )
# last_modified_by = db.Column(db.Integer)
active = db.Column(db.Boolean, default=True, nullable=False)
def __repr__(self):
return "<Users: {}".format(self.id)
def add_record(data):
return Users(
name=data.get("name", ''),
email=data.get("email"),
password_hash=password(data.get("password")),
photo_url=data.get("photo_url", ''),
# created_by = user_id,
# last_modified_by = user_id
)
def update_record(row, data):
row.name = data.get("name", row.name)
row.email = data.get("email", row.email)
if data.get("password", False):
row.password_hash = password(data.get("password"))
row.photo_url = data.get("photo_url", row.photo_url)
row.active = data.get("active", row.active)
# row.last_modified_by = user_id
def generate_token(user, password):
is_matched = check_password(user.password_hash, password)
if not is_matched:
return {"status": "Invalid Credentials!"}, 401
payload = {
'exp': datetime.datetime.now() + datetime.timedelta(days=30),
'iat': datetime.datetime.now(),
'sub': user.id
}
# row = AccessToken.add_row(user.id)
# db.session.add(row)
# db.session.commit()
return {
"token": str(jwt.encode(payload, key, algorithm="HS256")),
"status": "Login successfully"
}, 200
class Role(db.Model):
__tablename__ = 'sys_role'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(64), unique=True, comment=u'角色名称')
describe = db.Column(db.String(200), unique=True, comment=u'角色描述')
status = db.Column(db.Integer, default=1, comment=u'状态')
createTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'创建时间')
createBy = db.Column(db.String(50), comment=u'创建人')
updateTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'修改时间')
updateBy = db.Column(db.String(50), comment=u'修改人')
# @property
# def permissions(self):
# permissions = Permission.query.join(sys_role_permission).join(Role).filter(Role.id == self.id)
# return permissions
menus = db.relationship('Menu', secondary=sys_role_menu, backref=db.backref('menus', lazy='dynamic'))
# @property
# def menus(self):
# menus = Menu.query.join(sys_role_menu).join(Role).filter(Role.id == self.id).order_by(Menu.type, Menu.order).all()
# return menus
@property
def permission_names(self):
strs = ''
for i in range(len(self.menus)):
strs = strs + self.menus[i].name + ','
return strs
@property
def create_time(self):
return self.createTime.strftime('%Y-%m-%d')
@property
def menu_ids(self):
ids = []
for i in range(len(self.menus)):
if self.menus[i].url is not None:
ids.append(self.menus[i].id)
return ids
def __init__(self):
pass
def save(self):
globals.db.add(self)
globals.db.commit()
def update(self):
globals.db.commit()
def delete(self):
globals.db.delete(self)
globals.db.commit()
def __repr__(self):
return '<Role %r>' % self.name
class User(db.Model):
#creating user table in database
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50))
fullname = db.Column(db.String(50))
Password = db.Column(db.String(50))
Type = db.Column(db.String(50))
Contact = db.Column(db.Integer)
class Issue(db.Model):
"""
Description of Issue Model
Rows
------------------------
:id: int [pk]
:date_created: datetime
:month: Month
:year: int
:issue_tag: varchar [ref: > tags.name]
:cover: int [ref: > imgLinks.id]
:link: varchar
"""
id = db.Column(db.Integer, primary_key=True, nullable=False)
created_at = db.Column(db.DateTime)
month = db.Column(db.Enum(Month))
year = db.Column(db.Integer)
issue_tag = db.Column(db.String(20), db.ForeignKey('tag.name'))
cover = db.Column(db.Integer, db.ForeignKey('imgLink.id'))
link = db.Column(db.String(256))
description = db.Column(db.Text, nullable=True)
tag = db.relationship('Tag', lazy=False)
cover_img = db.relationship('ImgLink', lazy=False)
def __init__(self, coverId, month, year, link):
try:
tagName = str(month) + str(year[-2:])
self.created_at = datetime.datetime.now()
self.month = Month[month]
self.year = year
self.link = link
self.cover = coverId
self.setIssueTag(tagName)
db.session.add(self)
db.session.commit()
LOG.info("New Issue Created")
except BaseException:
LOG.error("Cannot create Issue", exc_info=True)
def setIssueTag(self, tagName):
existing_tags = Tag.query.filter_by(name=tagName).all()
if len(existing_tags) == 0:
existing_tag = Tag(tagName)
self.tag = existing_tag
db.session.commit()
else:
self.tag = existing_tags[0]
db.session.commit()
LOG.info(f"Issue tag set for { tagName }")
def setDescription(self, desc):
self.description = desc
db.session.commit()
class Wallet(db.Model):
__tablename__ = 'wallets'
id = db.Column(db.Integer, primary_key=True)
public_id = db.Column(db.String(60), unique=True, nullable=False, index=True)
user_id = db.Column(db.String(60), db.ForeignKey('users.public_id'))
balance = db.Column(db.Float, nullable=False, default=0.0)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=False)
updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
class HostVariable(db.Model):
""" HostVariable Model for storing inventory hosts variables """
__tablename__ = "host_variable"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), unique=False, nullable=False)
value = db.Column(db.String(1024), unique=False, nullable=False)
host_id = db.Column(db.Integer, db.ForeignKey('host.id'))
host = relationship("Host", back_populates="vars")
