class BankAccount(db.Model):
bank_account_no = db.Column(db.String(20),primary_key=True)
routing_number = db.Column(db.String(20),nullable=False)
user_id = db.Column(db.Integer,db.ForeignKey('user.id'),nullable=False)
amount = db.Column(db.Integer,nullable=False)
def __repr__(self):
return f"BankAccount('{self.bank_account_no}','{self.user_id}')"
class User(db.Model, UserMixin):
__tablename__ = "login_user"
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(length=30), nullable=False, unique=True)
email = db.Column(db.String(length=50), nullable=False, unique=True)
password = db.Column(db.String(length=100), nullable=False)
def __repr__(self):
return f"{self.username}"
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def save(self):
if not self.id:
db.session.add(self)
db.session.commit()
@staticmethod
def get_by_id(id):
return User.query.get(id)
@staticmethod
def get_by_email(email):
return User.query.filter_by(email=email).first()
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(120), unique=False, nullable=False)
def __repr__(self) -> str:
return f"User {self.username}"
class Post(db.Model):
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(20),nullable=False)
author = db.Column(db.String(20),nullable=False)
user_id = db.Column(db.Integer,db.ForeignKey('user.id'),nullable=False)
def __repr__(self):
return f"Post('{self.name}','{self.author}')"
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(60), unique=True, index=True)
username = db.Column(db.String(30), index=True)
password = db.Column(db.String(30))
def __init__(self, email, username, password):
self.email = email
self.username = username
self.password = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password, password)
def add_user(self):
with db.session.begin(subtransactions=True):
db.session.add(self)
db.session.commit()
@classmethod
def select_by_email(cls, email):
return cls.query.filter_by(email=email).first()
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), nullable=False, primary_key=True)
username = db.Column(db.String(), nullable=False, unique=True)
email = db.Column(db.String(80), nullable=False)
password = db.Column(db.String(255), nullable=False)
def __repr__(self):
return 'user {}'.format(self.username)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
# fは，formatを簡単に実現できるもの
return f"User('{self.username}', '{self.email}', {self.password})"
class TableModel(db.Model):
__tablename__ = "tabletypes"
Id = db.Column(db.Integer,
primary_key=True)
TableType = db.Column(db.String(100),
nullable=False,
unique=True)
class phd_students(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40))
father = db.Column(db.String(40))
email = db.Column(db.String(40))
phone = db.Column(db.String(20))
dob = db.Column(db.String(10))
score = db.Column(db.Integer)
gate = db.Column(db.Integer)
disc = db.Column(db.String)
comments = db.Column(db.String, nullable=True)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
#use a salted hash for password storage instead of plaintext
pw_hash = db.Column(db.String(160), nullable=False)
#defines what is returned when User table is queried
def __repr__(self):
return "User: %s" % self.username + ', ' + self.email
#compares salted hash pw to password, returns T/F
def check_password(self, password):
return check_password_hash(self.pw_hash, password)
class User(db.Model):
__tablename__ = 'flasklogin-users'
id = db.Column(db.Integer,
primary_key=True)
name = db.Column(db.String(100),
nullable=False,
unique=False)
email = db.Column(db.String(40),
unique=True,
nullable=False)
password = db.Column(db.String(200),
primary_key=False,
unique=False,
nullable=True)
def __init__(self,data):
self.id = data.get('id')
self.name = data.get('name')
self.email = data.get('email')
self.password = data.get('password')
def save_user(self) -> None:
self.set_password(self.password)
db.session.add(self)
db.session.commit()
def set_password(self, password) -> None:
"""Create hashed password."""
self.password = generate_password_hash(password, method='sha256')
def check_password(self, password) -> bool:
"""Check hashed password."""
return check_password_hash(self.password, password)
def __repr__(self):
return '<User {}>'.format(self.name)
@classmethod
def find_by_mail_id(cls, mail: str) -> "User":
return cls.query.filter_by(email=mail).first()
@classmethod
def find_by_id(cls, _id: int) -> "User":
return cls.query.filter_by(id=_id).first()
def delete_from_db(self) -> None:
db.session.delete(self)
db.session.commit()
class BlogPost(db.Model):
__tablename__ = "posts"
id = db.Column(db.Integer,primary_key=True)
title = db.Column(db.String,nullable=False)
description = db.Column(db.String,nullable=False)
def __init__(self, title, description):
self.title = title
self.description = description
def __repr__(self):
return '<{}-{}>'.format(self.title, self.description)
class RestaurantModel(db.Model):
__tablename__ = 'restaurants'
Id = db.Column(db.Integer,
primary_key=True)
Name = db.Column(db.String(100),
nullable=False,
unique=True)
Location = db.Column(db.String(100),
primary_key=False,
unique=False,
nullable=False)
Contact = db.Column(db.String(13),
unique=True,
nullable=False)
def __init__(self,data):
self.Id = data.get('Id')
self.Name = data.get('Name')
self.Location = data.get('Location')
self.Contact = data.get('Contact')
def create_restaurant(self) -> None:
db.session.add(self)
db.session.commit()
def delete_restaurant(self) -> None:
db.session.remove(self)
db.session.commit()
def __repr__(self):
return '<Restaurant {}>'.format(self.Name)
@classmethod
def show_all_restaurants(cls)-> list:
records = RestaurantModel.query.all()
print(records)
return records
class User(db.Model,UserMixin):
id = db.Column(db.Integer,primary_key=True)
username = db.Column(db.String(20),unique=True,nullable=False)
address = db.Column(db.String(50),unique=True,nullable=False)
email = db.Column(db.String(120),unique=True,nullable=False)
password = db.Column(db.String(60),nullable=False)
posts = db.relationship('Post',backref='user',lazy=True)
image_file = db.Column(db.String(20),nullable=False, default='default.jpg')
def get_reset_token(self,expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'],expires_sec)
return s.dumps({'user_id':self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}',{self.email},'{self.image_file}')"
class RestTableMapModel(db.Model):
__tablename__ = "restauranttabletypemapping"
Id = db.Column(db.Integer,
primary_key=True)
RestaurantId = db.Column(db.Integer(),
db.ForeignKey('restaurants.Id'))
TableTypeId = db.Column(db.Integer(),
db.ForeignKey('tabletypes.Id'))
TableCount = db.Column(db.Integer(),
nullable=False,
unique=False)
BookingCharges = db.Column(db.Integer(), nullable=False, unique=False)
def __init__(self,data):
self.Id = data.get("Id")
self.RestaurantId = data.get("RestaurantId")
self.TableTypeId = data.get("TableTypeId")
self.BookingCharges= data.get("BookingCharges")
def update_table_count(self):
self.TableCount -= 1
db.session.commit()
@classmethod
def book_table(cls,data,userId):
"""data = {"Name":"",
"TableType":""}"""
result = db.session.query(RestaurantModel.Name,
RestaurantModel.Location,
RestaurantModel.Contact,
TableModel.TableType,
RestTableMapModel.TableCount,
RestTableMapModel.BookingCharges,
RestTableMapModel.Id). \
join(RestTableMapModel, RestaurantModel.Id == RestTableMapModel.RestaurantId). \
join(TableModel, TableModel.Id == RestTableMapModel.TableTypeId). \
filter(RestaurantModel.Name == data["Name"]).\
filter(TableModel.TableType==int(data["TableType"])).first()
record ={"Name": getattr(result, "Name"),
"Location": getattr(result, "Location"),
"Contact": getattr(result, "Contact"),
"TableType": getattr(result, "TableType") + "seater",
"BookingCharges": getattr(result, "BookingCharges"),
}
if result.TableCount<=0:
return None
map_obj = RestTableMapModel.query.filter(RestTableMapModel.Id==result.Id).first()
map_obj.update_table_count()
bill = Bookings(MapId=map_obj.Id, UserId=userId)
bill.create_booking()
return record
@classmethod
def show_table(cls, restaurantName)->list:
results = db.session.query(RestaurantModel.Name,
RestaurantModel.Location,
RestaurantModel.Contact,
TableModel.TableType,
RestTableMapModel.TableCount,
RestTableMapModel.BookingCharges).\
join(RestTableMapModel,RestaurantModel.Id==RestTableMapModel.RestaurantId).\
join(TableModel, TableModel.Id==RestTableMapModel.TableTypeId).\
filter(RestaurantModel.Name==restaurantName).all()
records = list()
for result in results:
records.append({"Name":getattr(result,"Name"),
"Location": getattr(result,"Location"),
"Contact":getattr(result,"Contact"),
"TableType":getattr(result,"TableType")+"seater",
"TableCount":getattr(result,"TableCount"),
"BookingCharges":getattr(result, "BookingCharges")})
return records
class Bookings(db.Model):
__tablename__ = "bookings"
Id = db.Column(db.Integer,
primary_key=True,autoincrement=True)
MapId = db.Column(db.Integer())
UserId = db.Column(db.Integer())
PaymentStatus = db.Column(db.Enum('PAID', 'NOTPAID'))
BookingStatus = db.Column(db.Enum('BOOKED','CHECKEDIN','CANCELLED'))
def __init__(self, MapId, UserId, paymentStatus="NOTPAID", bookingStatus="BOOKED"):
self.MapId = MapId
self.UserId = UserId
self.PaymentStatus = paymentStatus
self.BookingStatus = bookingStatus
def create_booking(self)->None:
"""self.Id = mapped_obj.Id
self.MapId = mapped_obj.MapId
self.UserId = userId
self.PaymentStatus = mapped_obj.PaymentStatus
self.BookingStatus = mapped_obj.BookingStatus"""
db.session.add(self)
db.session.commit()
@classmethod
def get_booking_by_userId(cls, userId)->list:
results = db.session.query(RestaurantModel.Name,
RestaurantModel.Location,
RestaurantModel.Contact,
TableModel.TableType,
RestTableMapModel.TableCount,
RestTableMapModel.BookingCharges,
Bookings.BookingStatus,
Bookings.PaymentStatus,
Bookings.Id).\
join(RestTableMapModel,RestaurantModel.Id==RestTableMapModel.RestaurantId).\
join(TableModel, TableModel.Id==RestTableMapModel.TableTypeId).join(cls,Bookings.MapId==RestTableMapModel.Id).\
filter(cls.UserId==userId).all()
return results
@classmethod
def unpaid_booking(cls,userId)->list:
results = db.session.query(RestaurantModel.Name,
RestaurantModel.Location,
RestaurantModel.Contact,
TableModel.TableType,
RestTableMapModel.TableCount,
RestTableMapModel.BookingCharges,
Bookings.BookingStatus,
Bookings.PaymentStatus,
Bookings.Id). \
join(RestTableMapModel, RestaurantModel.Id == RestTableMapModel.RestaurantId). \
join(TableModel, TableModel.Id == RestTableMapModel.TableTypeId).join(cls,
Bookings.MapId == RestTableMapModel.Id). \
filter(cls.UserId == userId).filter(cls.PaymentStatus=="NOTPAID").filter(cls.BookingStatus!="CANCELLED").all()
return results
@classmethod
def change_status(cls,bookingId,status)->bool:
booking_obj = Bookings.query.get(bookingId)
if booking_obj:
booking_obj.BookingStatus = status
db.session.commit()
return True
else:
return False
@classmethod
def get_booking_by_id(cls,bookingId:int)->"Bookings":
booking_obj = Bookings.query.get(bookingId)
print(booking_obj)
return booking_obj
@classmethod
def get_booking_status(cls,bookingId:int)->str:
booking_obj = Bookings.query.filter(Bookings.Id==bookingId).one()
return booking_obj.BookingStatus
class UserStocks(db.Model):
user_id = db.Column(db.Integer,db.ForeignKey('user.id'),primary_key=True,nullable=False)
ticker_symbol = db.Column(db.String(20),db.ForeignKey('stock.ticker_symbol'),primary_key=True)
no_of_stocks = db.Column(db.Integer,nullable=False)
company_name = db.Column(db.String(20))
class SellStocks(db.Model):
ticker_symbol = db.Column(db.String(20),db.ForeignKey('stock.ticker_symbol'),primary_key=True)
user_id = db.Column(db.Integer,db.ForeignKey('user.id'),primary_key=True,nullable=False)
selling_price =db.Column(db.Integer,nullable=False)
no_of_stocks = db.Column(db.Integer,nullable=False)
sell_date = db.Column(db.DateTime,nullable=False,default=datetime.utcnow,primary_key=True)
class admin(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
email = db.Column(db.String(40))
password = db.Column(db.String)
class Stock(db.Model):
ticker_symbol = db.Column(db.String(20),primary_key=True)
company_name = db.Column(db.String(20),nullable=False)
price = db.Column(db.Integer,nullable=False)
def __repr__(self):
return f"Stock('{self.ticker_symbol}','{self.company_name}','{self.price}')"
class ta_email(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(40))
