class User(Model):
id = Column(db.Integer, primary_key=True)
username = Column(db.String(80), nullable=False)
email = Column(db.String(128), unique=True, nullable=False)
password_hash = Column(db.String(128), nullable=False)
confirmed = Column(db.Boolean, default=False)
todos = db.relationship(Todo, backref='user', lazy=True)
created_at = Column(db.DateTime, nullable=False, default=datetime.utcnow)
def set_password(self, password):
print('hello')
if len(password) < 8 or len(password) > 50:
raise AssertionError(
'Password must be between 8 and 50 characters')
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def save(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
return f'<User {self.username}>'
class EstabelecimentoModel(db.Model):
__tablename__ = 'estabelecimentos'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String())
cnpj = db.Column(db.String())
dono = db.Column(db.String())
telefone = db.Column(db.String())
def __repr__(self):
return f"<Estabelecimento {self.nome}>"
@property
def serialize(self):
cnpj = self.format_cnpj(self.cnpj)
return {
'id': self.id,
'nome': self.nome,
'cnpj': cnpj,
'dono': self.dono,
'telefone': self.telefone,
}
def format_cnpj(self, cnpj):
return cnpj[:2] + '.' + cnpj[2:5] + '.' + cnpj[5:8] + '/' + cnpj[
8:12] + '-' + cnpj[12:]
class Skill(db.Model):
__tablename__ = 'skills'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
skillCategoryId = db.Column(db.Integer)
elements = db.Column(db.String(100))
def insert(rowData):
record = Skill(
name = rowData['name'],
skillCategoryId = rowData['skillCategoryId'],
elements = rowData['elements']
)
db.session.add(record)
db.session.commit()
return 'success'
def update(rowData):
record = db.session.query(Skill).filter(Skill.id==rowData['id']).first()
record.name = rowData['name']
record.skillCategoryId = rowData['skillCategoryId']
record.elements = rowData['elements']
db.session.add(record)
db.session.commit()
return 'success'
class Recipe(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
name = db.Column(db.String(80))
ingredients = db.relationship('Ingredients',
backref='recipe',
lazy='dynamic')
imageUrl = db.Column(db.String(80))
created = db.Column(db.DateTime)
def __init__(self, user_id, name, ingredients, imageUrl, created=None):
self.user_id = user_id
self.name = name
self.ingredients = []
for ing in ingredients:
if 'name' in name:
name = ing.name
if name is None:
name = ing.get('name')
self.ingredients.append(Ingredients(self.id, name))
if created is None:
created = datetime.utcnow()
self.created = created
self.imageUrl = imageUrl
def __repr__(self):
return '<Recipe: user_id: %s, name: %s, imageUrl: %s>' % (
self.user_id, self.name, self.imageUrl)
class Phantom(db.Model):
__tablename__ = 'query_phantoms'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
rarityId = db.Column(db.Integer)
rarityName = db.Column(db.String(100))
elementId = db.Column(db.Integer)
elementName = db.Column(db.String(100))
minAt = db.Column(db.Integer)
maxAt = db.Column(db.Integer)
minHp = db.Column(db.Integer)
maxHp = db.Column(db.Integer)
mainSkillId = db.Column(db.Integer)
mainSkillName = db.Column(db.String(100))
subSkillId = db.Column(db.Integer)
subSkillName = db.Column(db.String(100))
limitBreak = db.Column(db.Integer)
def get_list():
records = db.session.query(Phantom).order_by(Phantom.id.desc()).all()
print(records)
return list(
map(lambda row: PhantomValue(**to_dict_from_sql_record(row)),
records))
class Url(db.Model):
id_url = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(1000))
# 50 because of custom urls
shortenend_url = db.Column(db.String(50), unique=True)
# 1 = random, 2 = custom
url_type = db.Column(db.Integer)
class RelationsModel(db.Model):
__tablename__ = 'relations'
id = db.Column(db.Integer, primary_key=True)
person_id = db.Column(db.Integer)
record_id = db.Column(db.Integer)
person_name = db.Column(db.String(255))
person_desc = db.Column(db.String)
person_img = db.Column(db.String(255))
record_title = db.Column(db.String(255))
record_desc = db.Column(db.String)
record_kind = db.Column(db.Integer)
record_img = db.Column(db.String(1200))
relate_words = db.Column(db.String(255))
def __init__(self, person_id, record_id, person_name, person_desc,
person_img, record_title, record_desc, record_kind,
record_img, relate_words):
self.person_id = person_id
self.record_id = record_id
self.person_name = person_name
self.person_desc = person_desc
self.person_img = person_img
self.record_title = record_title
self.record_desc = record_desc
self.record_kind = record_kind
self.record_img = record_img
self.relate_words = relate_words
def __repr__(self):
return '<person_name %r>' % self.person_name
class UserModel(db.Model):
__tablename__ = 'users'
__table_args__ = {'extend_existing': True}
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 return_all(cls):
def to_json(x):
return {'username': x.username}
return map(to_json, UserModel.query.all())
@staticmethod
def generate_hash(password):
return hasher.hash(password)
@staticmethod
def verifyHash(password, hash):
return hasher.verify(password, hash)
class User(SurrogatePK, Model):
__tablename__ = 'users'
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(100), unique=True, nullable=False)
password = Column(db.Binary(128), nullable=False)
image = Column(db.String(120), nullable=True)
token: str = ''
def __init__(self, **kwargs):
"""Create instance."""
db.Model.__init__(self, **kwargs)
self.set_password(kwargs.get('password'))
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
class Model(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
price = db.Column(db.Integer, nullable=False)
address = db.Column(db.String(255), nullable=False)
layout = db.Column(db.String(255), nullable=False)
station_distance = db.Column(db.Integer, nullable=False)
age = db.Column(db.Integer, nullable=False)
structure = db.Column(db.String(255), nullable=False)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
email = db.Column(db.String(80))
password = db.Column(db.String(200))
created = db.Column(db.DateTime)
recipes = db.relationship('Recipe', backref='user', lazy='dynamic')
token = db.Column(db.String(250))
def hash_password(self, password):
self.password = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password)
def generate_auth_token(
self,
expiration=(60 *
10)): # 60 * x mins - will probably want to increase this
# Check if valid token already exists, otherwise we can generate a new one
if self.token is not None:
token_state = User.verify_auth_token(self.token)
if token_state is "Valid":
log.info("Token is valid...returning")
return self.token
s = Serializer(secret_key, expires_in=expiration)
self.token = s.dumps({'id': self.id})
return self.token
def getID(self):
return self.id
@staticmethod
def verify_auth_token(token):
s = Serializer(secret_key)
try:
data = s.loads(token)
except SignatureExpired:
return "Expired"
except BadSignature:
return "Invalid"
return "Valid"
def __init__(self, username, email, password, recipes=[], created=None):
self.username = username
self.email = email
self.password = pwd_context.encrypt(password)
self.recipes = recipes
if created is None:
created = datetime.utcnow()
self.created = created
self.token = self.generate_auth_token()
def __repr__(self):
return '<User: id: %s, username: %s, email: %s, password: %s, token: %s>' % (
self.id, self.username, self.email, self.password, self.token)
class WebmapImagesModel(db.Model):
__tablename__ = 'webmap_images'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
image = db.Column(db.String(255))
def __init__(self, title, image):
self.title = title
self.image = image
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.String(64),
primary_key=True,
nullable=False,
unique=True)
pseudo = db.Column(db.String(64), primary_key=True, nullable=False)
creation_date = db.Column(db.DateTime, nullable=False)
update_date = db.Column(db.DateTime, nullable=True)
tweets = db.relationship('Tweet', back_populates="user")
class Todos(db.Model):
__table_name__ = "todos"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
contents = db.Column(db.String(200))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, onupdate=func.now())
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
user = db.relationship("User", backref="todos", lazy=True) # 객체 이름을 받는다.
class Tweet(db.Model):
__tablename__ = "tweets"
id = db.Column(db.String(64),
primary_key=True,
nullable=False,
unique=True)
message = db.Column(db.String(280), nullable=False)
creation_date = db.Column(db.DateTime, nullable=False)
update_date = db.Column(db.DateTime, nullable=True)
user_id = db.Column(db.String(64), db.ForeignKey(user.User.id))
user = db.relationship('User', back_populates="tweets")
class Report(db.Model):
__tablename__ = 'reports'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(30), nullable=False)
url = db.Column(db.String(50), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
def __init__(self, title, url, dt=datetime.now):
self.title = title
self.url = url
class CharacterModel(db.Model):
__tablename__ = 'characters'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
race = db.Column(db.String(120), nullable=False)
age = db.Column(db.String(120), nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def to_json(cls, x):
if not x:
return
return {'name': x.name, 'race': x.race, 'age': x.age}
@classmethod
def find_by_id(cls, id):
return cls.to_json(cls.query.filter_by(id=id).first())
@classmethod
def find_by_name(cls, name):
search = "{}%".format(name)
return map(cls.to_json, cls.query.filter(cls.name.ilike(search)).all())
@classmethod
def return_all(cls):
return map(cls.to_json, cls.query.all())
@classmethod
def update(cls, id, data):
character_query = cls.query.filter_by(id=id)
if not character_query.first():
raise LookupError
character_query.update(data)
db.session.commit()
@classmethod
def delete(cls, id):
character_query = cls.query.filter_by(id=id)
character_query.delete()
if not character_query.first():
raise LookupError
db.session.commit()
class WebmapsModel(db.Model):
__tablename__ = 'webmaps'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
description = db.Column(db.String)
url = db.Column(db.String(255))
def __init__(self, title, description, url):
self.title = title
self.description = description
self.url = url
class WebmapsWithImageModel(db.Model):
__tablename__ = 'webmaps_with_image'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(1000))
description = db.Column(db.String)
image = db.Column(db.String(1000))
def __init__(self, title, description, image):
self.title = title
self.description = description
self.image = image
class UserModel(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True)
password = db.Column(db.String(30))
plots = db.relationship('PlotModel', lazy='dynamic') # type: list
def __init__(self, username, password):
self.username = username
self.password = password
def json(self):
return {
'user': self.username,
'is_admin': (self.is_admin() is not None),
'plots': [plot.id for plot in self.plots]
}
def save(self):
db.session.add(self)
db.session.commit()
def is_admin(self):
return AdminModel.find_by_id(self.id)
@classmethod
def find_by_username(cls, username) -> UserModel:
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, _id) -> UserModel:
return cls.query.get(_id)
@classmethod
def set_master_admin(cls, password, access_level) -> bool:
_LOGGER.debug("Checking master admin..")
master_admin = UserModel.find_by_username("admin")
if not master_admin:
_LOGGER.debug("No master admin set, creating new..")
user = UserModel("admin", password)
user.save()
master_admin = AdminModel(user.id, access_level)
master_admin.save()
_LOGGER.debug(f"Admin 'admin' set with password '{password}'.")
return True
else:
_LOGGER.debug("Already set.")
return False
class Weapon(db.Model):
__tablename__ = 'query_weapons'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
slot1SkillId = db.Column(db.Integer)
slot1SkillName = db.Column(db.String(100))
slot1PowerId = db.Column(db.Integer)
slot1PowerName = db.Column(db.String(100))
slot2SkillId = db.Column(db.Integer)
slot2SkillName = db.Column(db.String(100))
slot2PowerId = db.Column(db.Integer)
slot2PowerName = db.Column(db.String(100))
elementId = db.Column(db.Integer)
elementName = db.Column(db.String(100))
rarityId = db.Column(db.Integer)
rarityName = db.Column(db.String(100))
typeId = db.Column(db.Integer)
typeName = db.Column(db.String(100))
minHp = db.Column(db.Integer)
maxHp = db.Column(db.Integer)
minAt = db.Column(db.Integer)
maxAt = db.Column(db.Integer)
weaponIdBeforeLimitBreak = db.Column(db.Integer)
def get_list():
records = db.session.query(Weapon).order_by(Weapon.id.desc()).all()
print(records)
return list(
map(lambda row: WeaponValue(**to_dict_from_sql_record(row)),
records))
class Skill(db.Model):
__tablename__ = 'query_skills'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
elements = db.Column(db.String(100))
skillCategoryId = db.Column(db.Integer)
skillCategoryName = db.Column(db.String(100))
def get_list():
lists = db.session.query(Skill).order_by(Skill.id.asc()).all()
return list(
map(lambda row: SkillValue(**to_dict_from_sql_record(row)), lists))
class DigitalsModel(db.Model):
__tablename__ = 'digitals_distinct'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
contents = db.Column(db.String)
url = db.Column(db.String(255))
img_url = db.Column(db.String(255))
def __init__(self, title, contents, url, img_url):
self.title = title
self.contents = contents
self.url = url
self.img_url = img_url
class ShishisModel(db.Model):
__tablename__ = 'hakodateshishi'
id = db.Column(db.Integer, primary_key=True)
paragraph_title = db.Column(db.String)
paragraph_body = db.Column(db.String)
url = db.Column(db.String(255))
image_url = db.Column(db.String(1200))
def __init__(self, paragraph_title, paragraph_body, url, image_url):
self.paragraph_title = paragraph_title
self.paragraph_body = paragraph_body
self.url = url
self.image_url = image_url
class Account(BaseModel, db.Model):
__tablename__ = 'accounts'
id = db.Column(db.Integer, primary_key=True)
ext_account_id = db.Column(db.String(256))
user_public_key = db.Column(db.String(66))
pk_sender = db.Column(db.String(256))
token_address = db.Column(db.String(256))
time_created = db.Column(db.DateTime(timezone=True),
server_default=func.now())
time_updated = db.Column(db.DateTime(timezone=True), onupdate=func.now())
def __init__(self,
ext_account_id,
user_public_key,
token_address,
pk_sender=None):
self.ext_account_id = ext_account_id
self.user_public_key = user_public_key
self.token_address = token_address
self.pk_sender = pk_sender
@classmethod
def find_by_ext_account_id(cls, ext_account_id):
records = None
try:
records = cls.query.filter_by(ext_account_id=ext_account_id).one()
except:
records = None
return records
@classmethod
def find_by_user_public_key(cls, user_public_key):
return cls.query.filter_by(user_public_key=user_public_key).all()
@classmethod
def get_all_accounts(cls):
try:
return cls.query.order_by(Account.time_created).all()
except:
return None
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Search(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
name_en = db.Column(db.String(255), nullable=False)
search_order = db.Column(db.Integer, nullable=False)
search_type = db.Column(db.Integer, nullable=False)
step = db.Column(db.Integer, nullable=True)
digit = db.Column(db.Integer, nullable=True)
unit = db.Column(db.String(255), nullable=True)
search_min = db.Column(db.Integer, nullable=True)
search_max = db.Column(db.Integer, nullable=True)
pull_menu_num = db.Column(db.Integer, nullable=True)
items = db.Column(db.String(255), nullable=True)
ambiguous = db.Column(db.Boolean, nullable=False)
weight = db.Column(db.Boolean, nullable=False)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.text('NOW()'))
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.text('CURRENT_TIMESTAMP'),
server_onupdate=db.text('CURRENT_TIMESTAMP'))
class Settlement(db.Model):
id = db.Column(db.Integer, primary_key=True)
ext_account_id_to_settle = db.Column(db.String(256))
sender_withdrawal_amount = db.Column(db.Float)
time_created = db.Column(db.DateTime(timezone=True), server_default=func.now())
time_updated = db.Column(db.DateTime(timezone=True), onupdate=func.now())
def __init__(self, ext_account_id_to_settle, sender_withdrawal_amount):
self.ext_account_id_to_settle = ext_account_id_to_settle
self.sender_withdrawal_amount = sender_withdrawal_amount
def __repr__(self):
return '<Settlement: %r>' % self.ext_account_id
@classmethod
def find_by_ext_account_id(cls, ext_account_id):
records = None
try:
records = cls.query.filter_by(ext_account_id_to_settle=ext_account_id). \
order_by(Settlement.time_created).First()
except:
records = None
return records
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Power(db.Model):
__tablename__ = 'powers'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
def get_list():
records = db.session.query(Power).order_by(Power.id.asc()).all()
return list(
map(lambda row: PowerValue(**to_dict_from_sql_record(row)),
records))
def insert(rowData):
record = Power(name=rowData['name'])
db.session.add(record)
db.session.commit()
return 'success'
def update(rowData):
record = db.session.query(Power).filter(
Power.id == rowData['id']).first()
record.name = rowData['name']
db.session.add(record)
db.session.commit()
return 'success'
class PlotModel(db.Model):
__tablename__ = 'plot'
id = db.Column(db.Integer, primary_key=True)
cpm = db.Column(db.String(30))
values = db.Column(db.JSON)
data = db.Column(db.JSON)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('UserModel') # type: src.UserModel
def __init__(self, cpm: str, values, data, user_id):
self.cpm = cpm
self.values = values
self.data = data
self.user_id = user_id
def json(self):
return {
'plot': {
'user': self.user.username,
'cpm': self.cpm,
'values': self.values,
'data': self.data
}
}
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_id(cls, _id) -> PlotModel:
return cls.query.get(_id)
