class EthContact(db.Model):
__tablename__ = 'eth_contact'
address = db.Column(db.String(42), primary_key=True)
name = db.Column(db.String(255), index=True)
desc = db.Column(db.String(255))
email = db.Column(db.String(255), index=True)
phone = db.Column(db.String(255), index=True)
eth_balance = db.Column(db.Float(), default=0)
ogn_balance = db.Column(db.Float(), default=0)
dai_balance = db.Column(db.Float(), default=0)
investor = db.Column(db.Boolean())
presale_interest = db.Column(db.Boolean())
dapp_user = db.Column(db.Boolean())
employee = db.Column(db.Boolean())
exchange = db.Column(db.Boolean())
company_wallet = db.Column(db.Boolean())
investor_airdrop = db.Column(db.Boolean())
token_count = db.Column(db.Integer())
transaction_count = db.Column(db.Integer())
tokens = db.Column(JSONB)
last_updated = db.Column(db.DateTime(),
server_default=db.func.now(),
onupdate=db.func.now())
created_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
country_code = db.Column(db.String(2))
def __str__(self):
return '%s' % (self.name)
class User(db.Model, MainModel):
__tablename__ = 'user'
__table_args__ = {'comment': '用户'}
# __permission__ = {}
username = db.Column(db.String(20), unique=True,
nullable=False, comment='用户名', )
password_hash = db.Column(db.String(255), nullable=False, comment='密码')
fullname = db.Column(db.String(40), nullable=False, comment='真实姓名', )
phone = db.Column(db.String(11), nullable=False, comment='电话', )
create_at = db.Column(db.DateTime(), nullable=False, comment='创建时间', )
update_at = db.Column(db.DateTime(), nullable=False, comment='更新时间', )
status = db.Column(db.Boolean(), nullable=False, comment='账户状态', )
head_img = db.Column(db.LargeBinary(65536), nullable=True, comment="头像", ) # max16M
# LargeBinary(16777216) longblob str 二进制，max32M
permissions = db.relationship(
'Permission', secondary=user_permission) # 操作权限
roles = db.relationship('Role', secondary=user_role) # 角色
@property
def password(self):
raise AttributeError("password can't to read!")
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password): # 哈希对比
"""
对比密码
:param hash: 哈希密码
:param password: 要与哈希比较的纯文本密码。
:return:
"""
return check_password_hash(self.password_hash, password)
class Category(db.Model):
__tablename__ = 'category'
id = db.Column(db.String(36),
primary_key=True,
default=lambda: str(uuid4()))
name = db.Column(db.String(80))
profit_percent = db.Column(db.Float(2), default=0.0)
created_at = db.Column(db.DateTime(timezone=True), default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
is_active = db.Column(db.Boolean, unique=False, default=True)
deleted_at = db.Column(db.DateTime(timezone=True), default=None)
product_line = db.relationship('ProductLine', backref='product_line')
def __init__(self, **kwargs):
super().__init__(**kwargs)
for keys in kwargs:
if keys == 'id' or keys == 'name':
if kwargs[keys] is None or kwargs[keys] == '':
raise NullOrNoneValueException(f'The {keys} is empty')
def serialize(self) -> dict:
return {
"id": self.id,
"name": self.name,
"profit_percent": self.profit_percent,
"created_at": self.created_at,
"updated_at": self.updated_at,
"is_active": self.is_active,
"deleted_at": self.deleted_at
}
class Purchase(db.Model):
contract_address = db.Column(db.String(255), primary_key=True)
buyer_address = db.Column(db.String(255), index=True)
listing_address = db.Column(db.String(255),
db.ForeignKey('listing.contract_address'),
nullable=False)
stage = db.Column(db.Integer())
created_at = db.Column(db.DateTime(timezone=True))
buyer_timeout = db.Column(db.DateTime(timezone=True))
class Identity(db.Model):
eth_address = db.Column(db.Numeric(precision=50, scale=0),
primary_key=True)
phone = db.Column(db.String(20), index=True)
verified = db.Column(db.Boolean())
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
onupdate=func.now())
class EthNotificationEndpoint(db.Model):
id = db.Column(db.Integer, primary_key=True)
eth_address = db.Column(db.String(255), index=True)
device_token = db.Column(db.String(255), index=True)
type = db.Column(db.Enum(EthNotificationTypes))
active = db.Column(db.Boolean())
verified = db.Column(db.Boolean())
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
expires_at = db.Column(db.DateTime(timezone=True))
class VerificationCode(db.Model):
phone = db.Column(db.String(20), index=True)
email = db.Column(db.String(256), index=True)
code = db.Column(db.String(10), primary_key=True)
expires_at = db.Column(db.DateTime(timezone=True))
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
onupdate=func.now())
class VerificationCode(db.Model):
eth_address = db.Column(db.Numeric(precision=50, scale=0),
primary_key=True)
phone = db.Column(db.String(20), index=True)
code = db.Column(db.String(10))
expires_at = db.Column(db.DateTime(timezone=True))
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
onupdate=func.now())
class CirculatingSupply(db.Model):
__tablename__ = 'circulating_supply'
id = db.Column(db.Integer, primary_key=True)
supply_amount = db.Column(db.Float(), default=0)
snapshot_date = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
created_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
def __str__(self):
return '%s' % (self.name)
class User(db.Model):
login = db.Column(db.String(8), primary_key=True)
email = db.Column(db.String(100))
date_join = db.Column(db.DateTime(), default=datetime.datetime.utcnow())
last_login = db.Column(db.DateTime(), default=datetime.datetime.utcnow())
collections = db.relationship('Collection', backref='user', lazy='dynamic')
def __init__(self, login):
self.login = login
self.email = "*****@*****.**" % login
def __repr__(self):
return '<User %r>' % self.login
class Listing(db.Model):
contract_address = db.Column(db.String(255), primary_key=True)
owner_address = db.Column(db.String(255), index=True)
registry_id = db.Column(db.Integer())
price = db.Column(db.Integer())
units = db.Column(db.Integer())
expired = db.Column(db.Boolean())
ipfs_hash = db.Column(db.String(255))
ipfs_data = db.Column(db.JSON())
created_at = db.Column(db.DateTime(timezone=True))
expires_at = db.Column(db.DateTime(timezone=True))
class Competition(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), nullable=False)
start_on = db.Column(db.DateTime())
end_on = db.Column(db.DateTime())
groundtruth = db.Column(db.String(500), nullable=False)
submissions = db.relationship('Submission',
backref='competition',
lazy='dynamic')
def __repr__(self):
return self.name
def __unicode__(self):
return self.name
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
fs_uniquifier = db.Column(db.String(255), unique=True, nullable=False)
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary='roles_users', backref=db.backref('users', lazy='dynamic'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
phone_number = db.Column(db.String(50), nullable=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
verification_code = db.Column(db.String(50), nullable=True)
active = db.Column(db.Boolean(), default=False)
has_verified_account = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def generate_verification_code(self):
self.verification_code = random.randint(100000, 999999)
def __str__(self):
if self.first_name and self.last_name:
return "{} {}".format(self.first_name, self.last_name)
return self.email
@property
def full_name(self):
if self.first_name and self.last_name:
return f'{self.first_name} {self.last_name}'
return ''
class User(db.Model):
__tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(60), nullable=False)
registered = db.Column(db.DateTime(), nullable=False)
idRole = db.Column(db.Integer, db.ForeignKey('UserRole.id'))
role = db.relationship("UserRole", foreign_keys=[idRole], cascade="merge")
idStatus = db.Column(db.Integer, db.ForeignKey('UserStatus.id'))
status = db.relationship("UserStatus", foreign_keys=[idStatus], cascade="merge")
devices = db.relationship("Device", uselist=True, backref=db.backref('user_device'),
cascade="save-update, merge, delete")
aws_accounts = db.relationship("AwsAccount", uselist=True, backref=db.backref('user_account'),
cascade="save-update, merge, delete")
def __init__(self, username=None, password='', email=None, role_id=None, status_id=None, registered=None):
self.username = username
self.password = pwd_context.encrypt(password)
self.email = email
self.idRole = role_id
self.idStatus = status_id
self.registered = registered
self.devices = []
def __repr__(self):
return '<User {0}, {1}>'.format(self.username, self.email)
def verify_password(self, password):
return pwd_context.verify(password, self.password)
class Actor(db.Model):
__tablename__ = 'actor'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=True)
time = db.Column(db.DateTime())
movies = db.relationship("Movie", secondary=association_table, back_populates="actors")
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.String(36),
primary_key=True,
default=lambda: str(uuid.uuid4()))
username = db.Column(db.String(20), nullable=False)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
profile = db.relationship('Profile', back_populates='user', uselist=False)
posts = db.relationship(Post, back_populates='user')
def serialize(self, detail=False):
response = {
'id': self.id,
'username': self.username,
'created_at': self.created_at
}
posts = []
if self.posts:
posts = [post.serialize() for post in self.posts]
profile = None
if self.profile:
profile = self.profile.serialize()
if detail:
response.update({'profile': profile, 'posts': posts})
return response
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(255))
current_login_ip = db.Column(db.String(255))
login_count = db.Column(db.Integer)
def __repr__(self):
return '<models.User[email=%s]>' % self.email
class UserExternalService(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
user = db.relationship(User, backref="external_services")
service = db.Column(db.String,
nullable=False) # UserExternalServiceEnum. _ .value
service_user_id = db.Column(db.String, nullable=False)
auth_info = db.Column(db.JSON) # e.g. access token
user_info = db.Column(db.JSON)
last_used_at = db.Column(db.DateTime(),
default=datetime.utcnow,
nullable=False)
__table_args__ = (
UniqueConstraint("user_id",
"service",
name="user_external_service_user_id_service_uniq"),
UniqueConstraint(
"service",
"service_user_id",
name="user_external_service_service_service_user_id_uniq",
),
)
class DonationModel(db.Model):
__tablename__ = "donations"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
attendance_id = db.Column(db.Integer,
db.ForeignKey("attendances.id"),
nullable=False)
transfer_id = db.Column(db.Integer,
db.ForeignKey("transfers.id"),
nullable=True)
year = db.Column(db.Integer, nullable=False)
month = db.Column(
db.Enum("january",
"february",
"march",
"april",
"may",
"june",
"july",
"august",
"september",
"october",
"november",
"december",
name="month"))
mmk_amount = db.Column(db.Float())
jpy_amount = db.Column(db.Float())
paid_at = db.Column(db.DateTime(), nullable=True)
def __init__(self, user_id: int, attendance_id: int, transfer_id: int,
year: int, month: str, mmk_amount: float, jpy_amount: float,
paid_at: datetime) -> None:
self.user_id = user_id
self.attendance_id = attendance_id
self.transfer_id = transfer_id
self.year = year
self.month = month
self.mmk_amount = mmk_amount
self.jpy_amount = jpy_amount
self.paid_at = paid_at
def __repr__(self):
return f"<Donation Records for user_id {self.user_id}>"
@staticmethod
def create_donation(new_donation) -> bool:
"""
create new_donation
:param new_donation:
:return: bool
"""
try:
db.session.add(new_donation)
db.session.commit()
return True
except SQLAlchemyError as e:
# to put log
return False
class LodgingBusiness(LocalBusiness):
# amenityFeature, audience, availableLanguage, checkinTime, checkoutTime, petsAllowed, starRating
license_number = db.Column('license_number', db.String(1000))
license_expiry = db.Column('license_expiry', db.DateTime())
last_inspection = db.Column('last_inspection', db.DateTime())
status_code = db.Column('status_code', db.String(1000))
checkinTime = db.Column('checkinTime', db.DateTime())
checkoutTime = db.Column('checkoutTime', db.DateTime())
rooms = db.Column('rooms', db.Integer())
__mapper_args__ = {'polymorphic_identity': 'lodgingbusiness'}
id = db.Column(GUID(),
db.ForeignKey('local_business.id'),
primary_key=True)
class TokenTransaction(db.Model):
__tablename__ = 'token_transaction'
tx_hash = db.Column(db.String(66), primary_key=True)
from_address = db.Column(db.String(42), index=True)
to_address = db.Column(db.String(42), index=True)
amount = db.Column(db.Float())
block_number = db.Column(db.Integer())
notification_sent = db.Column(db.Boolean())
timestamp = db.Column(db.DateTime(timezone=True))
last_updated = db.Column(db.DateTime(),
server_default=db.func.now(),
onupdate=db.func.now())
created_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
def __str__(self):
return '%s' % (self.name)
class Echange(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user1 = db.Column(db.String(8), db.ForeignKey('user.login'))
user2 = db.Column(db.String(8), db.ForeignKey('user.login'))
#User1 donne ecocup1
ecocup1 = db.Column(db.Integer(), db.ForeignKey('ecocup.id'))
ecocup2 = db.Column(db.Integer(), db.ForeignKey('ecocup.id'))
date_execution = db.Column(db.DateTime(), default=None)
date_conf1 = db.Column(db.DateTime(), default=None)
date_conf2 = db.Column(db.DateTime(), default=None)
date_cancelled = db.Column(db.DateTime(), default=None)
canceller = db.Column(db.String(8), default=None)
date_creation = db.Column(db.DateTime(),
default=datetime.datetime.utcnow())
def __repr__(self):
return '<Echange %r>' % self.id
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
description = db.Column(db.String(2000))
photo = db.Column(db.String(2000))
funding_start_date = db.Column(db.DateTime(), nullable=False)
funding_end_date = db.Column(db.DateTime(), nullable=False)
creation_date = db.Column(db.DateTime(), nullable=False)
goal = db.Column(db.Float)
long = db.Column(db.Numeric(11, 8))
lat = db.Column(db.Numeric(11, 8))
stars = db.Column(db.Float)
event_start_date = db.Column(db.DateTime(), nullable=False)
event_end_date = db.Column(db.DateTime())
location = db.Column(db.String(200), nullable=False)
user_creator = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
tags = db.relationship('Tag',
secondary=tags,
lazy='subquery',
backref=db.backref('tags', lazy=True))
watchers = db.relationship("User", secondary=watchers, backref="watching")
backers = db.relationship("Funded", back_populates="backers")
votes = db.relationship("VotedTest", back_populates="votes")
def __init__(self, name, description, funding_start_date, funding_end_date,
goal, event_start_date, event_end_date, location,
user_creator, lat, long, photo):
self.name = name
self.description = description
self.funding_start_date = funding_start_date
self.funding_end_date = funding_end_date
self.creation_date = datetime.datetime.now()
self.goal = goal
self.event_start_date = event_start_date
self.event_end_date = event_end_date
self.location = location
self.user_creator = user_creator
self.lat = lat
self.long = long
self.photo = photo
def __repr__(self):
return '<Event %r>' % self.name
class StockMonitor(db.Model):
'''
{
"id": 2,
"stock_id": "sz000069",
"threshold_value": "2.78",
"threshold_type": "percent",
"status": "0",
"user_id": "default",
"over_limit": 1,
"over_count": 0,
"monitoring_type": "high"
}
'''
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
stock_id = db.Column(db.String(50))
# high low
monitoring_type = db.Column(db.String(50))
threshold_value = db.Column(db.String(50))
# absolute percent
threshold_type = db.Column(db.String(50))
# 0 1 2 3 4
status = db.Column(db.String(50))
# the notification limit times after the value over
over_limit = db.Column(db.String(50))
over_count = db.Column(db.Integer, default=0)
user_id = db.Column(db.String(50))
time_stamp = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
__table_args__ = (UniqueConstraint('stock_id', 'user_id',
'monitoring_type', 'threshold_value'), )
def __json__(self):
return {
'id': self.id,
'stock_id': self.stock_id,
'threshold_value': self.threshold_value,
'threshold_type': self.threshold_type,
'status': self.status,
'user_id': self.user_id,
'over_limit': self.over_limit,
'over_count': self.over_count,
'monitoring_type': self.monitoring_type,
'time_stamp': self.time_stamp.strftime(r"%Y-%m-%d %H:%M:%S"),
}
@staticmethod
def of(json):
return StockMonitor(stock_id=json['stock_id'],
monitoring_type=json['monitoring_type'],
threshold_value=json['threshold_value'],
threshold_type=json['threshold_type'],
status=json['status'],
user_id=json['user_id'],
over_limit=json['over_limit'])
class EmailList(db.Model): __tablename__ = 'email_list' email = db.Column(db.String(255), primary_key=True, autoincrement=False) unsubscribed = db.Column(db.Boolean()) created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now()) def __str__(self): return '%s' % (self.email)
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid4()))
name = db.Column(db.String(36), unique=True)
cost_values = db.Column(db.Float(20))
unit_per_box = db.Column(db.Numeric(6))
weight_per_unit = db.Column(db.String(10))
measure_unit = db.Column(db.String(10), nullable=False)
shelf_life = db.Column(db.String(10))
sku = db.Column(db.String(10), unique=True)
description = db.Column(db.String(70))
created_at = db.Column(db.DateTime(timezone=True), default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
deleted_at = db.Column(db.DateTime(timezone=True), default=None)
is_active = db.Column(db.Boolean(10), default=True)
id_product_line = db.Column(
db.String(36),
db.ForeignKey('product_line.id')
)
def __init__(self, **kwargs):
super().__init__(**kwargs)
for keys in kwargs:
if kwargs[keys] is None or kwargs[keys] == '':
raise NullValueException(f'The field {keys} can not be null')
def serialize(self):
return {
"id": self.id,
"name": self.name,
"cost_values": self.cost_values,
"unit_per_box": int(self.unit_per_box),
"weight_per_unit": self.weight_per_unit,
'measure_unit': self.measure_unit,
"shelf_life": self.shelf_life,
"sku": self.sku,
"description": self.description,
"id_product_line": self.id_product_line,
"is_active": self.is_active,
"created_at": self.created_at,
"updated_at": self.updated_at,
"deleted_at": self.deleted_at
}
class SocialStat(db.Model):
__tablename__ = 'social_stat'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), index=True)
timestamp = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
subscribed_count = db.Column(db.Integer())
def __str__(self):
return '%s' % (self.name)
class MessageLog(db.Model):
__tablename__ = 'message_log'
id = db.Column(db.BigInteger, primary_key=True)
email = db.Column(db.String(255), index=True)
msg_purpose = db.Column(db.String(128), index=True)
msg_subject = db.Column(db.String(128))
msg_text = db.Column(db.Text())
msg_html = db.Column(db.Text())
msg_sent = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
class Contributor(db.Model):
__tablename__ = 'contributor'
username = db.Column(db.String(255), primary_key=True, autoincrement=False)
commits = db.Column(db.Integer())
avatar = db.Column(db.String(255))
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
def __str__(self):
return '%s' % (self.username)
