class MovieModel(db.Model):
__tablename__ = 'movie'
movieId = db.Column(UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
title = db.Column(db.String(length=120))
director = db.Column(db.String(length=80))
releaseDate = db.Column(db.Date)
closeDate = db.Column(db.Date)
ageCategory = db.Column(db.String(length=40))
movieCategory = db.Column(db.String(length=80))
duration = db.Column(db.Integer)
seances = db.relationship("SeanceModel", backref="movie")
def __init__(self,
_id=None,
title=None,
director=None,
releaseDate=None,
closeDate=None,
ageCategory=None,
movieCategory=None,
duration=None):
self.id = _id or id
self.title = title
self.director = director
self.releaseDate = releaseDate
self.closeDate = closeDate
self.ageCategory = ageCategory
self.movieCategory = movieCategory
self.duration = duration
class EmployeeModel(db.Model):
__tablename__ = 'employee'
employeeId = db.Column(UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = db.Column(db.String(length=80))
surname = db.Column(db.String(length=80))
login = db.Column(db.String(length=80))
password = db.Column(db.String(length=80))
isAdmin = db.Column(db.Boolean)
def __init__(self,
_id=None,
name=None,
surname=None,
login=None,
password=None,
isAdmin=False):
self.id = _id or id
self.name = name
self.surname = surname
self.login = login
self.password = password
self.isAdmin = isAdmin
def __repr__(self):
return f"<User {self.name} + {self.surname}"
class Company(db.Model):
__tablename__ = 'company'
id_ = db.Column(db.Integer, primary_key=True)
symbol = db.Column(db.String(50), unique=True)
company_name = db.Column(db.String(50), unique=True)
industry = db.Column(db.String(50))
volatility = db.Column(db.String(20))
def __init__(self, symbol, company_name, industry, volatility):
self.symbol = symbol
self.company_name = company_name
self.industry = industry
self.volatility = volatility
def __repr__(self):
return "Get Company: {}!".format(self.symbol)
def to_json(self):
return {
'id_': self.id_,
'symbol': self.symbol,
'company_name': self.company_name,
'industry': self.industry,
'volatility': self.volatility
}
class SensorRooms(db.Model):
sensor_id = db.Column(db.String(100), primary_key=True)
room = db.Column(db.String(50), primary_key=True)
def __init__(self, sensor_id, room):
self.sensor_id = sensor_id
self.room = room
def __repr__(self):
return '<Room: %r, Sensor ID: %r>' % (self.room, self.sensor_id)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
# Relationship User <--> Post
posts = db.relationship('Post', backref='author', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
class PhoneToken(db.Model):
token = db.Column(db.String(100), primary_key=True)
router_id = db.Column(db.String(30))
def __init__(self, token, router_id):
self.router_id = router_id
self.token = token
def __repr__(self):
return '<PhoneToken: ' + str(self.token) + ', Router: ' + str(
self.router_id) + '>'
class Uv(db.Model):
router_id = db.Column(db.String(30), primary_key=True)
sensor_id = db.Column(db.String(100), primary_key=True)
timestamp = db.Column(db.Integer, primary_key=True)
value = db.Column(db.Integer, primary_key=True)
def __init__(self, router_id, sensor_id, timestamp, value):
self.router_id = router_id
self.sensor_id = sensor_id
self.timestamp = timestamp
self.value = value
class RouterSensors(db.Model):
router_id = db.Column(db.String(20), primary_key=True)
sensor_id = db.Column(db.String(100), primary_key=True)
def __init__(self, router_id, sensor_id):
self.router_id = router_id
self.sensor_id = sensor_id
def __repr__(self):
return '<Router: ' + str(self.router_id) + ', Sensor: ' + str(
self.sensor_id) + '>'
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(40), unique=True)
password = db.Column(db.String(40))
is_admin = db.Column(db.Integer)
def __init__(self, username, password):
self.username = username
self.password = password
self.is_admin = 0
def __repr__(self):
return '<User: %r>' % self.username
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.String(80), nullable=False)
user_email = db.Column(db.String(120), unique=True, nullable=False)
user_password = db.Column(db.String(120), nullable=False)
user_style = db.Column(db.Integer, default=0)
user_company_selection = db.Column(db.String)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
def __repr__(self):
return '<User %r>' % self.user_name
class Actuator(db.Model):
id = db.Column(db.Integer, primary_key=True)
actuator_id = db.Column(db.String(20), unique=True)
type = db.Column(db.String(20), nullable=False)
functions = db.Column(db.Text, nullable=False)
router_id = db.Column(db.String(20), nullable=False)
def __init__(self, actuator_id, router_id, type, functions):
self.actuator_id = actuator_id
self.type = type
self.functions = functions
self.router_id = router_id
def __repr__(self):
return '<Actuator: ' + str(self.type) + ', ID: ' + str(
self.actuator_id) + ', Router: ' + str(self.router_id) + '>'
class StockPrice(db.Model):
__tablename__ = 'price'
id_ = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date)
high = db.Column(db.Float(precision=4))
low = db.Column(db.Float(precision=4))
open_ = db.Column(db.Float(precision=4))
close = db.Column(db.Float(precision=4))
vol = db.Column(db.Integer)
adj_close = db.Column(db.Float(precision=4))
comp = db.Column(db.String(20))
def __init__(self, date, high, low, open_, close, vol, adj_close, comp):
self.date = date
self.high = high
self.low = low
self.open_ = open_
self.close = close
self.vol = vol
self.adj_close = adj_close
self.comp = comp
def __repr__(self):
return "Stock Price ('{}', '{}', '{}', '{}')".format(
self.date, self.vol, self.close, self.comp)
@classmethod
def find_all_by_query(cls, comp):
return cls.query.filter_by(comp=comp).all()
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(100), nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) # Author
username = db.Column(db.String, nullable=False) # Author, easier for username display, no circular import
class HallModel(db.Model):
__tablename__ = 'hall'
hallId = db.Column(UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = db.Column(db.String(length=80), unique=True, nullable=True)
numOfSeats = db.Column(db.Integer)
rows = db.Column(db.Integer)
seatsPerRow = db.Column(db.Integer)
availability = db.Column(db.Boolean)
seances = db.relationship("SeanceModel", backref="hall")
seats = db.relationship("SeatModel", backref="hall", cascade="all,delete")
def __init__(self,
_id=None,
name=None,
rows=None,
seatsPerRow=None,
availability=True,
numOfSeats=None):
self.id = _id or id
self.name = name
self.numOfSeats = rows * seatsPerRow
self.rows = rows
self.seatsPerRow = seatsPerRow
self.availability = availability
class ItemImage(db.Model):
__tablename__ = 'item_image'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
item_id = db.Column(
db.Integer,
db.ForeignKey('item.id', onupdate='CASCADE', ondelete='CASCADE'))
url = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
def __init__(self, url='', item_id=None):
self.url = url
self.item_id = item_id
def postRecord(self):
db.session.add(self)
db.session.commit()
db.session.refresh(self)
return self
@classmethod
def getImage(cls, image_id):
record = cls.query.filter_by(id=image_id).first()
return record
# class ItemImageSchema(ma.SQLAlchemyAutoSchema):
# class Meta:
# model = ItemImage
# # load_instance = True
class Warnings(db.Model):
w_id = db.Column(db.Integer, primary_key=True)
w_level = db.Column(db.Integer)
w_msg = db.Column(db.String(400))
w_time = db.Column(db.BigInteger)
originType = db.Column(db.String(40))
originName = db.Column(db.String(40))
def __init__(self, w_level, w_msg, w_time, originType, originName):
self.w_level = w_level
self.w_msg = w_msg
self.w_time = w_time
self.originType = originType
self.originName = originName
def __repr__(self):
return '<Warning: %r>' % self.originName
class Auth(db.Model):
__tablename__ = 'auth'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(
db.Integer,
db.ForeignKey('user.id', onupdate='CASCADE', ondelete='CASCADE'))
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(300), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
def __init__(self, user_id='', email='', password=''):
self.user_id = user_id
self.email = email
self.password = hashlib.sha256(password.encode('utf-8')).hexdigest()
def setAttr(self, user_id='', email='', password=''):
self.user_id = user_id
self.email = email
self.password = hashlib.sha256(password.encode('utf-8'))
def postRecord(self):
db.session.add(self)
db.session.commit()
return
@classmethod
def getRecordsAll(cls):
records = cls.query.all()
return records
@classmethod
def getRecordByEmail(cls, email):
record = cls.query.filter_by(email=email).first()
return record
@classmethod
def getRecordsByUserId(cls, user_id):
record = cls.query.filter_by(user_id=user_id).first()
return record
class RouterAuthUsers(db.Model):
router_id = db.Column(db.String(40), primary_key=True)
user_id = db.Column(db.Integer, primary_key=True)
def __init__(self, router_id, user_id):
self.router_id = router_id
self.user_id = user_id
def __repr__(self):
return '<Router: %s, Users: %s>' % (self.router_id, str(self.user_id))
class User(UserMixin, db.Model):
"""User account model."""
__tablename__ = 'Users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=False)
email = db.Column(EmailType)
password = db.Column(db.String(200),
primary_key=False,
unique=False,
nullable=False)
phone_number = db.Column(PhoneNumberType())
created_on = db.Column(db.DateTime,
index=False,
unique=False,
nullable=True)
last_login = db.Column(db.DateTime,
index=False,
unique=False,
nullable=True)
def set_number(self, phone_number):
"""return user number"""
self.phone_number = phone_number
def get_number(self):
"""return user number"""
return self.phone_number
def set_password(self, password):
"""Create hashed password."""
self.password = generate_password_hash(password, method='sha256')
def check_password(self, password):
"""Check hashed password."""
return check_password_hash(self.password, password)
def __repr__(self):
return '<User {}>'.format(self.name)
class UserRouters(db.Model):
router_id = db.Column(db.String(20), primary_key=True)
user_id = db.Column(db.Integer, primary_key=True)
def __init__(self, router_id, user_id):
self.router_id = router_id
self.user_id = user_id
def __repr__(self):
return '<Router: ' + str(self.router_id) + ', User: '******'>'
class Sensor(db.Model):
id = db.Column(db.Integer, primary_key=True)
sensor_id = db.Column(db.String(100), unique=True)
config = db.Column(db.Integer, nullable=False)
def __init__(self, sensor_id, config):
self.sensor_id = sensor_id
self.config = config
def __repr__(self):
return '<Sensor: ' + str(self.sensor_id) + ', Config: ' + str(
self.config) + '>'
class Router(db.Model):
id = db.Column(db.Integer, primary_key=True)
router_id = db.Column(db.String(20), unique=True)
last_heard = db.Column(db.Integer)
def __init__(self, router_id):
self.router_id = router_id
self.last_heard = 0
def __repr__(self):
return '<Router: ' + str(self.router_id) + ', LP: ' + str(
self.last_heard) + '>'
class AgeCategoryModel(db.Model):
__tablename__ = 'age_category'
ageCategoryId = db.Column(UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = db.Column(db.String(length=80), unique=True, nullable=False)
def __init__(self, _id=None, name=None):
self.id = _id
self.name = name
class User(db.Model, UserMixin):
# db.Model is necessary to store data in the database
# UserMixin is here to use a standard model for login and sessions
# email and username must be unique and have a maximum length
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(25), unique=True)
username = db.Column(db.String(20), unique=True)
password = db.Column(db.String(100))
posts = db.relationship('Post', backref='author', lazy='dynamic')
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
db.session.commit()
return self
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
db.session.commit()
return self
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
# To get the list of all posts made by people the current user follows
return db.session.query(Post).join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).order_by(Post.date.desc())
class Address(db.Model):
__tablename__ = 'address'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
postal_code = db.Column(db.Integer, nullable=False)
prefecture = db.Column(db.String(50))
municipalities = db.Column(db.String(255), nullable=False)
other = db.Column(db.String(255))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
def __init__(self,
postal_code='',
prefecture='',
city='',
municipalities='',
other=''):
self.postal_code = postal_code
self.prefecture = prefecture
self.city = city
self.municipalities = municipalities
self.other = other
def postRecord(self):
db.session.add(self)
db.session.commit()
return {
'id': self.id,
'postal_code': self.postal_code,
'prefecture': self.prefecture,
'city': self.city,
'municipalities': self.municipalities,
'other': self.other
}
class Tag(db.Model):
__tablename__ = 't_tag'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.String(255))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now)
def __init__(self, code):
self.code = code
@classmethod
def getUserInfo(cls, user_id):
record = cls.query.filter_by(id=user_id).first()
return {
'id': record.id,
'image': record.image,
'display_name': record.display_name
}
class Category(db.Model):
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
items = db.relationship('Item', backref='category')
def __init__(self, name='', category_id=1):
self.name = name
self.id = category_id
def setAttr(self, name=''):
self.name = name
def postRecord(self):
db.session.add(self)
db.session.commit()
return self
@classmethod
def getCategory(cls, category_id):
record = cls.query.filter_by(id=category_id).first()
return record
@classmethod
def addTestData(cls):
categories = []
data_lists = {1: '米・穀物', 2: '野菜', 3: '果物', 4: 'その他'}
for k, v in data_lists.items():
categories.append(cls(name=v, category_id=k))
db.session.add_all(categories)
db.session.commit()
# class CategorySchema(ma.SQLAlchemyAutoSchema):
# class Meta:
# model = Category
class RemainingFormat(db.Model):
__tablename__ = 'remaining_format'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
item = db.relationship('Item', backref='remaining_format')
def __init__(self, name='', format_id=1):
self.name = name
self.id = format_id
def setAttr(self, name=''):
self.name = name
def postRecord(self):
db.session.add(self)
db.session.commit()
return self
@classmethod
def getRecord(cls, category_id):
record = cls.query.filter_by(id=category_id).first()
return record
@classmethod
def addTestData(cls):
models = []
data_lists = {1: 'whole', 2: 'day', 3: 'week', 4: 'month'}
for k, v in data_lists.items():
models.append(cls(format_id=k, name=v))
db.session.add_all(models)
db.session.commit()
class Koe(db.Model):
__tablename__ = 'koe'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(25), nullable=False)
text = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('user.id', onupdate='CASCADE', ondelete='CASCADE'))
item_id = db.Column(db.Integer, db.ForeignKey('item.id', onupdate='CASCADE', ondelete='CASCADE'))
item = db.relationship('Item', primaryjoin='Koe.item_id==Item.id', backref='koes')
favorites = db.relationship('KoeFavorite', backref='koe')
def __init__(self, title='', text='', user_id='', item_id=''):
self.title = title
self.text = text
self.user_id = user_id
self.item_id = item_id
def postRecord(self):
db.session.add(self)
db.session.commit()
return self
@classmethod
def getRecordById(cls, koe_id):
record = cls.query.filter_by(id=koe_id).first()
return record
@classmethod
def getRecordsBySearch(cls, args):
records = cls.query
for k, v in args.items():
if (k == 'text'):
records = records.filter(or_(cls.title.like('%' + v + '%'),
cls.text.like('%' + v + '%')))
if (k == 'order_by'):
order_by = v
if (int(v) == 1):
current_app.logger.debug(order_by)
records = records.order_by(desc(cls.updated_at))
records = records.all()
return records
@classmethod
def getRecordsByItem(cls, item_id):
record = cls.query.filter_by(item_id=item_id).order_by(desc(cls.updated_at)).all()
return record
@classmethod
def getRecordsByPostUser(cls, user_id):
record = cls.query.filter_by(user_id=user_id).order_by(desc(cls.updated_at)).all()
return record
@classmethod
def getRecordsByCatchUser(cls, user_id):
record = cls.query.filter(cls.item.has(user_id=user_id)).order_by(desc(cls.updated_at)).all()
return record
@classmethod
def getRecordsByNew(cls):
record = cls.query.order_by(desc(cls.updated_at)).all()
return record
@classmethod
def addTestData(cls):
categories = []
data_lists = ['grain', 'vegetable', 'fruit', 'other']
for data in data_lists:
categories.append(cls(data))
db.session.add_all(categories)
db.session.commit()
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(150))
email = db.Column(db.String(150), unique=True)
password = db.Column(db.String(150))
