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)