class GithubAccessHistory(db.Model):
"""History of Github access permission by Admins on Staffs.
Contains all the detailed invoked or revoked histories of
github permission on staffs. The action field will contain any
comments about the action such as invoked permission, revoked
permission, cancelled pending, etc.
This model is backreferenced by Admin through action_by field,
and Staff through action_on field. Therefore, the Admin and the
Staff related to a particular history should be supplied to the
initializer through the respected arguments.
admin_id and staff_id will then automatically contain the ids of
respective models related to the particular history.
"""
__tablename__ = 'githubaccesshistory'
id = db.Column(db.Integer, primary_key=True)
action = db.Column(db.String(128), nullable=False)
datetime = db.Column(db.DateTime, nullable=False)
admin_id = db.Column(db.Integer, db.ForeignKey('admins.id'))
staff_id = db.Column(db.Integer, db.ForeignKey('staffs.id'))
def __init__(self, action, datetime, action_by, action_on):
self.action = action
self.datetime = datetime
self.action_by = action_by
self.action_on = action_on
class GatewayModel(CRUDMixin, HelperMixin, db.Model):
__tablename__ = 'gateway_model'
id = db.Column(db.Integer, primary_key=True)
gateway_id = db.Column(db.Integer,
db.ForeignKey('gateway.id',
ondelete='CASCADE',
onupdate='CASCADE'),
unique=True,
index=True,
nullable=False)
model_id = db.Column(db.Integer,
db.ForeignKey('data_model.id',
ondelete='CASCADE',
onupdate='CASCADE'),
nullable=False)
created_at = db.Column(db.DateTime, default=utils.get_utc_now)
gateway = db.relationship('Gateway',
backref=db.backref('gateway_model',
lazy='joined'),
lazy='joined')
data_model = db.relationship('DataModel',
backref=db.backref('gateway_model',
lazy='joined'),
lazy='joined')
def __init__(self, gateway_id=None, model_id=None):
self.gateway_id = gateway_id
self.model_id = model_id
def __repr__(self):
return "<GatewayModel(id='%s',gateway_id='%s',model_id='%s',created_at='%s')>" % (
str(self.id), str(self.gateway_id), str(
self.model_id), str(self.created_at))
class User(CRUDMixin, HelperMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.VARCHAR(20))
password = db.Column(db.VARCHAR(64))
phone = db.Column(db.VARCHAR(15))
gateway_id = db.Column(db.Integer,
db.ForeignKey('gateway.id',
ondelete='CASCADE',
onupdate='CASCADE'),
nullable=False)
gateway = db.relation('Gateway', backref='user', lazy=False)
created_at = db.Column(db.DateTime, default=utils.get_utc_now)
def __init__(self,
username=None,
password=None,
gateway_id=None,
phone=None):
self.username = username
self.password = password
self.gateway_id = gateway_id
self.phone = phone
def __repr__(self):
return "<User(id='%s',username='******',password='******',gateway_id='%s',created_at='%s')>" % (
str(self.id), self.username, self.password, self.gateway_id,
str(self.created_at))
class HisWeather(CRUDMixin, HelperMixin, db.Model):
__tablename__ = 'his_weather'
id = db.Column(db.Integer, primary_key=True)
publish_date = db.Column(db.DATE)
created_at = db.Column(db.DateTime, default=utils.get_utc_now)
region_id = db.Column(db.Integer,
db.ForeignKey('gateway.id',
ondelete='CASCADE',
onupdate='CASCADE'),
nullable=False)
temperature = db.Column(db.FLOAT)
humidity = db.Column(db.FLOAT)
weather = db.Column(db.VARCHAR(45))
def __init__(self,
publish_date=None,
region_id=None,
temperature=None,
humidity=None,
weather=None):
self.publish_date = publish_date
# self.created_at = created_at
self.region_id = region_id
self.temperature = temperature
self.humidity = humidity
self.weather = weather
def __repr__(self):
return "<HisWeather(id='%s',publish_date='%s',created_at='%s',region_id='%s',temperature='%s',humidity='%s'," \
"weather='%s')>" % (str(self.id), str(self.publish_date), str(self.created_at), str(self.region_id),
str(self.temperature), str(self.humidity), self.weather)
class PredictedPower(CRUDMixin, HelperMixin, db.Model):
__tablename__ = 'predicted_power'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=utils.get_utc_now)
region_id = db.Column(db.Integer,
db.ForeignKey('gateway.id',
ondelete='CASCADE',
onupdate='CASCADE'),
nullable=False)
predict_date = db.Column(db.DATE)
publish_date = db.Column(db.DATE)
order = db.Column(db.Integer)
power = db.Column(db.FLOAT)
def __init__(self,
region_id=None,
predict_date=None,
publish_date=None,
order=None,
power=None):
self.publish_date = publish_date
self.region_id = region_id
self.predict_date = predict_date
self.order = order
self.power = power
def __repr__(self):
return "<PredictedPower(id='%s',created_at='%s',region_id='%s',predict_date='%s',order='%s',power='%s')>" % \
(str(self.id), str(self.created_at), str(self.region_id), str(self.predict_date), str(self.order),
str(self.power))
class Staff(db.Model):
"""Staff model for the staffs.
Staff is a simple model for the staffs, where each staff is
identified by his email. It contains a github_status field
which contains the current access status of the staff to the
organization's github repositories. This field can contain
one of the following values:
1. 'uninvited': the staff has not been invited yet
2. 'pending': the staff is invited but not accepted invitation
3. 'granted': the staff has access to the github repos
This model is backreferenced by an Admin who created the Staff.
During initialization, it is required to pass the Admin through
added_by parameter.
Any history of invoked or revoked permissions on this Staff can be
accessed through github_actions field.
"""
__tablename__ = 'staffs'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), nullable=False, unique=True)
github_status = db.Column(db.String(128), nullable=False)
admin_id = db.Column(db.Integer, db.ForeignKey('admins.id'))
github_actions = db.relationship('GithubAccessHistory', backref='action_on')
def __init__(self, email, added_by, github_status='uninvited'):
self.email = email
self.github_status = github_status
self.added_by = added_by
class ActualWeather(CRUDMixin,HelperMixin,db.Model):
__tablename__='actual_weather'
id = db.Column(db.Integer,primary_key=True)
publish_date = db.Column(db.DATE)
created_at = db.Column(db.VARCHAR(100))
region_id = db.Column(db.Integer,db.ForeignKey('region.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
forecast_data = db.Column(db.DATE)
order = db.Column(db.Integer)
temperature = db.Column(db.FLOAT)
humidity = db.Column(db.FLOAT)
weather=db.Column(db.VARCHAR(45))
def __init__(self,publish_date=None,created_at=None,region_id=None,forecast_data=None,order=None,temperature=None,humidity=None,weather=None):
self.publish_date = publish_date
self.created_at = created_at
self.region_id = region_id
self.forecast_data = forecast_data
self.order = order
self.temperature = temperature
self.humidity = humidity
self.weather = weather
def __repr__(self):
return "<ActualWeather(id='%s',publish_date='%s',created_at='%s',region_id='%s',forecast_data='%s',order='%s',temperature='%s',humidity='%s',weather='%s')>" % (
str(self.id),str(publish_date),str(created_at),str(self.region_id),str(self.forecast_data),str(self.order),str(self.temperature),str(self.humidity),self.weather)
class DataModel(CRUDMixin,HelperMixin,db.Model):
__tablename__='data_model'
id = db.Column(db.Integer,primary_key=True)
dataset_id = db.Column(db.Integer, db.ForeignKey('dataset.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
name = db.Column(db.VARCHAR(100))
algorithm_type = db.Column(db.VARCHAR(50))
serialization = db.Column(db.Integer)
description = db.Column(db.VARCHAR(200))
created_at = db.Column(db.DateTime)
status = db.Column(db.VARCHAR(1))
dataset = db.relationship('DataSet', backref=db.backref('data_model', lazy='joined'), lazy='joined')
def __init__(self,dataset_id=None,name=None,algorithm_type=None,serialization=None,description=None,created_at=None,status=None):
self.dataset_id = dataset_id
self.name = name
self.algorithm_type = algorithm_type
self.serialization = serialization
self.description = description
self.created_at = created_at
self.status = status
def __repr__(self):
return "<DataModel(id='%s',dataset_id='%s',name='%s',algorithm_type='%s',serialization='%s',description='%s',created_at='%s',status='%s')>" % (
str(self.id),str(dataset_id),self.name,self.algorithm_type,self.serialization,self.description,str(self.created_at),str(self.status))
class Blog(db.Model):
__tablename__ = 'blog'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64), unique=True)
content = db.Column(db.Text, )
author_id = db.Column(db.Integer, db.ForeignKey('user.id'), comment=u'作者')
def __repr__(self):
return self.title
class Tree(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
# recursive relationship
parent_id = db.Column(db.Integer, db.ForeignKey('tree.id'))
parent = db.relationship('Tree', remote_side=[id], backref='children')
def __str__(self):
return "{}".format(self.name)
class Resume(db.Model):
id = db.Column(db.Integer, primary_key=True)
main_flag = db.Column(db.Boolean, nullable=False)
mongo_key = db.Column(db.String(100), nullable=False)
user_id = db.Column(db.String(32), db.ForeignKey('user.id'))
@property
def get_data(self):
dictionary = self.__dict__
try:
del dictionary['_sa_instance_state']
dictionary['user_id'] = self.user_id.hex
except:
pass
return dictionary
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120))
text = db.Column(db.Text, nullable=False)
date = db.Column(db.Date)
# some sqlalchemy_utils data types (see https://sqlalchemy-utils.readthedocs.io/)
background_color = db.Column(ColorType)
created_at = db.Column(ArrowType, default=arrow.utcnow())
user_id = db.Column(UUIDType(binary=False), db.ForeignKey(User.id))
user = db.relationship(User, foreign_keys=[user_id], backref='posts')
tags = db.relationship('Tag', secondary=post_tags_table)
def __str__(self):
return "{}".format(self.title)
class ActualPower(CRUDMixin,HelperMixin,db.Model):
__tablename__='actual_power'
id = db.Column(db.Integer,primary_key=True)
collect_data = db.Column(db.DATE)
region_id = db.Column(db.Integer,db.ForeignKey('region.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
power=db.Column(db.FLOAT)
def __init__(self,collect_data=None,region_id=None,power=None):
self.collect_data = collect_data
self.region_id = region_id
self.power = power
def __repr__(self):
return "<ActualPower(id='%s',collect_data='%s',region_id='%s',power='%s')>" % (
str(self.id),str(created_at),str(self.region_id),str(self.power))
class User(db.Model):
id = db.Column(UUIDType(binary=False), default=uuid.uuid4, primary_key=True)
# use a regular string field, for which we can specify a list of available choices later on
type = db.Column(db.String(100))
# fixed choices can be handled in a number of different ways:
enum_choice_field = db.Column(db.Enum(EnumChoices), nullable=True)
sqla_utils_choice_field = db.Column(ChoiceType(AVAILABLE_USER_TYPES), nullable=True)
sqla_utils_enum_choice_field = db.Column(ChoiceType(EnumChoices, impl=db.Integer()), nullable=True)
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
# some sqlalchemy_utils data types (see https://sqlalchemy-utils.readthedocs.io/)
email = db.Column(EmailType, unique=True, nullable=False)
website = db.Column(URLType)
ip_address = db.Column(IPAddressType)
currency = db.Column(CurrencyType, nullable=True, default=None)
timezone = db.Column(TimezoneType(backend='pytz'))
dialling_code = db.Column(db.Integer())
local_phone_number = db.Column(db.String(10))
featured_post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
featured_post = db.relationship('Post', foreign_keys=[featured_post_id])
@hybrid_property
def phone_number(self):
if self.dialling_code and self.local_phone_number:
number = str(self.local_phone_number)
return "+{} ({}) {} {} {}".format(self.dialling_code, number[0], number[1:3], number[3:6], number[6::])
return
@phone_number.expression
def phone_number(cls):
return sql.operators.ColumnOperators.concat(cast(cls.dialling_code, db.String), cls.local_phone_number)
def __str__(self):
return "{}, {}".format(self.last_name, self.first_name)
def __repr__(self):
return "{}: {}".format(self.id, self.__str__())
@phone_number.expression
def phone_number(cls):
return sql.operators.ColumnOperators.concat(cast(cls.dialling_code, db.String), cls.local_phone_number)
def __str__(self):
return "{}, {}".format(self.last_name, self.first_name)
def __repr__(self):
return "{}: {}".format(self.id, self.__str__())
#---<Create M2M table>---#
post_tags_table = db.Table('post_tags', db.Model.metadata,
db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120))
text = db.Column(db.Text, nullable=False)
date = db.Column(db.Date)
# some sqlalchemy_utils data types (see https://sqlalchemy-utils.readthedocs.io/)
background_color = db.Column(ColorType)
created_at = db.Column(ArrowType, default=arrow.utcnow())
user_id = db.Column(UUIDType(binary=False), db.ForeignKey(User.id))
def get_data(self):
dictionary = self.__dict__
try:
del dictionary['_sa_instance_state']
if dictionary['deadline'] != None:
dictionary['deadline'] = str(dictionary['deadline'])
dictionary['crawl_date'] = str(dictionary['crawl_date'])
dictionary['skill_tag'] = dictionary['skill_tag'].split(',')
except:
pass
return dictionary
skills_sector_table = db.Table(
'skill_sector', db.Model.metadata,
db.Column('job_skill_id', db.Integer, db.ForeignKey('jobskill.id')),
db.Column('job_sector_id', db.Integer, db.ForeignKey('jobsector.id')))
class JobSkill(db.Model):
__tablename__ = "jobskill"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
sector = db.relationship('JobSector', secondary=skills_sector_table)
def __str__(self):
return "{}".format(self.name)
@property
def get_data(self):
dictionary = self.__dict__
class Social(db.Model):
id = db.Column(db.String(128), primary_key=True)
name = db.Column(db.String(100), primary_key=True)
user_id = db.Column(db.String(32), db.ForeignKey('user.id'))
#! coding: utf8
from admin import db
from flask_login import UserMixin
user_role = db.Table(
'user_role',
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
db.Column('role_id', db.Integer, db.ForeignKey('role.id'), primary_key=True),
)
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
is_admin = db.Column(db.Integer, default=0, nullable=False) # 是否管理员 0 不是 1 是
status = db.Column(db.Integer, default=1, nullable=False) # 是否有效 0 无效 1有效
roles = db.relationship(
"Role",
secondary=user_role,
lazy='subquery',
backref=db.backref('users', lazy=True),
)
# 功能模块-用户关联部分
# 定义一对多关系
