class Like(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user_who_liked_quote = db.relationship('User',
foreign_keys=[user_id],
backref='user_liked',
cascade='all')
quote_id = db.Column(db.Integer, db.ForeignKey('quote.id'))
quote_liked_by_user = db.relationship('Quote',
foreign_keys=[quote_id],
backref='liked_quote',
cascade='all')
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
@classmethod
def like_quote(cls, like_quote):
add_like = cls(user_id=like_quote["login_id"],
quote_id=like_quote["liked_quote_value"])
db.session.add(add_like)
db.session.commit()
flash("You liked a quote!")
return add_like
class category(db.Model):
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class Listing(db.Model):
__tablename__ = 'listings'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey("users.id",
ondelete="cascade",
onupdate='cascade'),
nullable=False)
location_from = db.Column(db.String())
location_to = db.Column(db.String())
description = db.Column(db.String())
date = db.Column(db.DateTime)
price = db.Column(db.String)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
user = db.relationship('User',
foreign_keys=[user_id],
backref="user_listings")
users_request_this_listing = db.relationship('User',
secondary=requests,
lazy='dynamic',
backref=db.backref('listings',
lazy=True))
class order_item(db.Model):
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'))
product_id = db.Column(db.Integer, db.ForeignKey('product.id'))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
order = db.relationship('order', backref='ordered_items', cascade='all')
class billing_address(db.Model):
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
street = db.Column(db.String(255))
city = db.Column(db.String(255))
state = db.Column(db.String(255))
zipcode = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
customer_billing_address = db.relationship('customer',
backref='billing_address',
cascade='all')
@classmethod
def validate_billing(cls, new_billing_data):
is_valid = True
if len(new_billing_data["street"]) < 1 or not re.search(
"^[#.0-9a-zA-Z\s,-]+$", new_billing_data["street"]):
is_valid = False
flash("Please enter a valid street address.")
if len(new_billing_data["city"]) < 1 or not re.search(
"^[a-zA-Z',.\s-]{1,25}$", new_billing_data["city"]):
is_valid = False
flash("Please enter a valid city.")
if len(new_billing_data["state"]) < 1 or not re.search(
"^[a-zA-Z',.\s-]{1,25}$", new_billing_data["state"]):
is_valid = False
flash("Please enter a state.")
if len(new_billing_data["zipcode"]) < 1 or not re.search(
"^\d{5}(?:[-\s]\d{4})?$", new_billing_data["zipcode"]):
is_valid = False
flash("Please enter a valid zipcode.")
return is_valid
@classmethod
def add_billing_shipping(cls, new_billing_data):
add_billing = cls(customer_id=new_billing_data['customer_id'],
street=new_billing_data['street'],
city=new_billing_data['city'],
state=new_billing_data['state'],
zipcode=new_billing_data['zipcode'])
db.session.add(add_billing)
db.session.commit()
flash("New Billing Address Added")
return add_billing
@classmethod
def delete_billing_address(cls, delete_billing_data):
delete_billing_address = billing_address.query.filter(
billing_address.customer_id ==
delete_billing_data["delete_billing"]).delete()
db.session.commit()
flash("You Deleted This Billing Address.")
return delete_billing_address
class Dojo(db.Model):
__tablename__ = 'dojos'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(45))
city = db.Column(db.String(45))
state = db.Column(db.String(45))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255))
password_hash = db.Column(db.String(255))
liked_tweets = db.relationship("Tweet", secondary=likes_table)
followers = db.relationship(
"User",
secondary=followers_table,
primaryjoin=id == followers_table.c.followed_id,
secondaryjoin=id == followers_table.c.follower_id,
backref="following")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
def full_name(self):
return f"{self.first_name} {self.last_name}"
@classmethod
def add_new_user(cls, data):
new_user = cls(first_name=data['first_name'],
last_name=['last_name'],
email=data['email'],
password_hash=bcrypt.generate_password_hash(
data['password']))
db.session.add(new_user)
db.session.commit()
return new_user
@classmethod
def find_registration_errors(cls, form_data):
errors = []
if len(form_data['first_name']) < 1:
errors.append("first name must be at least 1 character long")
if len(form_data['last_name']) < 1:
errors.append("last name must be at least 1 character long")
if not EMAIL_REGEX.match(form_data['email']):
errors.append("invalid email")
if form_data['password'] != request.form['confirm']:
errors.append("passwords dont match")
if len(form_data['password']) < 8:
errors.append("password isn't long enough")
return errors
@classmethod
def register_new_user(cls, form_data):
errors = cls.find_registration_errors(form_data)
valid = len(errors) == 0
data = cls.add_new_user(form_data) if valid else errors
return {"status": "good" if valid else "bad", "data": data}
class product_category(db.Model):
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.Integer, db.ForeignKey('product.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
product = db.relationship('product', backref='products', cascade='all')
category = db.relationship('category',
backref='product_category',
cascade='all')
class product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
description = db.Column(db.String(255))
price = db.Column(db.String(255))
imgname = db.Column(db.String(255))
imgname2 = db.Column(db.String(255))
routename = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class GameType(db.Model):
__tablename__ = "game_types"
id = db.Column(db.Integer, primary_key=True)
game_name = db.Column(db.String(255))
time_limit = db.Column(db.Integer)
min_players = db.Column(db.Integer)
max_players = db.Column(db.Integer)
ante = db.Column(db.Integer)
max_raise = db.Column(db.Integer)
rounds = db.relationship("GameRound", back_populates="game_type")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class Ninja(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(45))
last_name = db.Column(db.String(45))
dojo_id = db.Column(db.Integer,
db.ForeignKey("dojos.id", ondelete="cascade"))
dojo = db.relationship('Dojo',
foreign_keys=[dojo_id],
backref="dojos_ninjas")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
def name(self):
return self.first_name + " " + self.last_name
class Follow(db.Model):
__tablename__ = "follows"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user1 = db.relationship("User", backref="likes", cascade="all")
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user2 = db.relationship("User", backref="likes", cascade="all")
created_at = db.Column(db.DateTime, server_default=func.now())
class order(db.Model):
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
s_address_id = db.Column(db.Integer, db.ForeignKey('shipping_address.id'))
b_address_id = db.Column(db.Integer, db.ForeignKey('billing_address.id'))
order_total = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
customer = db.relationship('customer', backref='orders', cascade='all')
shipping_address = db.relationship('shipping_address',
backref='orders',
cascade='all')
billing_address = db.relationship('billing_address',
backref='orders',
cascade='all')
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.String(255))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
balance = db.Column(db.Integer)
photo = db.Column(db.BLOB)
current_game_id = db.Column(
db.Integer, db.ForeignKey("games.id"),
nullable=True) # is null if not currently in a game
current_game = db.relationship("Game",
foreign_keys=[current_game_id],
backref="game_users")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class GameRound(db.Model):
__tablename__ = "game_rounds"
id = db.Column(db.Integer, primary_key=True)
round_num = db.Column(db.Integer)
face_up = db.Column(
db.Boolean, unique=False, default=False
) # false: round of cards is dealt face down, true: face up
betting = db.Column(
db.Boolean, unique=False, default=False
) # false: no betting after round dealt, true: betting after round dealt
game_type_id = db.Column(db.Integer,
db.ForeignKey("game_types.id"),
nullable=True)
game_type = db.relationship("GameType", back_populates="rounds")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class Quote(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
posted_by = db.relationship('User',
foreign_keys=[user_id],
backref='user_quotes',
cascade='all')
author_of_quote = db.Column(db.String(255))
quote_content = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
@classmethod
def validate_quote(cls, new_quote_data):
is_valid = True
if len(new_quote_data["author_of_quote"]) < 3:
is_valid = False
flash("Please enter a valid author name.")
if len(new_quote_data["quote_content"]) < 10:
is_valid = False
flash("Please enter a quote length of 10 characters long.")
return is_valid
@classmethod
def add_new_quote(cls, new_quote_data):
add_new_quote = cls(user_id=new_quote_data["login_id"],
author_of_quote=new_quote_data["author_of_quote"],
quote_content=new_quote_data["quote_content"])
db.session.add(add_new_quote)
db.session.commit()
flash("Quote successfully added!!")
return add_new_quote
@classmethod
def delete_quote(cls, delete_quote_data):
quote_instance_to_delete = Quote.query.filter(
Quote.id == delete_quote_data['deleted_quote_value']).delete()
db.session.commit()
flash("You deleted this quote!")
return quote_instance_to_delete
class Message(db.Model):
__tablename__ = "messages"
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.String(255))
player_id = db.Column(db.Integer,
db.ForeignKey("players.player_id"),
nullable=True)
player = db.relationship("Player",
foreign_keys=[player_id],
back_populates="messages")
game_id = db.Column(
db.Integer, db.ForeignKey("games.id"),
nullable=True) # is null if not in a game while sending message
game = db.relationship("Game",
foreign_keys=[game_id],
backref="game_messages")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class Tweet(db.Model):
__tablename__ = "tweets"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
author_id = db.Column(db.Integer, db.ForeignKey("users.id"))
author = db.relationship("User", backref="tweets", cascade="all")
likers = db.relationship("User", secondary=likes_table)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
@classmethod
def add_new_tweet(cls, tweet):
db.session.add(tweet)
db.session.commit()
return tweet
def age(self):
age = self.created_at
return age
class Card(db.Model):
__tablename__ = "cards"
id = db.Column(db.Integer, primary_key=True)
number = db.Column(
db.Integer) # 2-10: 2-10, 11: jack, 12: queen, 13: king, 14: ace
suit = db.Column(db.Integer) # 1: clubs, 2: diamonds, 3: hearts, 4: spades
face_up = db.Column(
db.Boolean, unique=False,
default=False) # false: card is face down, true: card is face up
game_id = db.Column(db.Integer, db.ForeignKey("games.id"), nullable=True)
game = db.relationship("Game",
foreign_keys=[game_id],
backref="game_cards")
player_id = db.Column(db.Integer,
db.ForeignKey("players.player_id"),
nullable=True)
player = db.relationship("Player", back_populates="cards")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class wishlist(db.Model):
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
product_id = db.Column(db.Integer, db.ForeignKey('product.id'))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
customer_who_wished = db.relationship('customer',
backref='customer_made_wish',
cascade='all')
product_they_wished_for = db.relationship('product',
backref='customer_loves_product',
cascade='all')
@classmethod
def delete_wish(cls, delete_wish_data):
wish_instance_to_delete = wishlist.query.filter(
wishlist.product_id == delete_wish_data['product_id']).delete()
db.session.commit()
flash("You deleted this from your wishlist!")
return wish_instance_to_delete
class Player(db.Model):
__tablename__ = "players"
id = db.Column(db.Integer, primary_key=True)
total_bet = db.Column(db.Integer)
result = db.Column(
db.Integer
) # 0: waiting, 1: playing, 2: win, 3: loss, 4: exited before playing
turn = db.Column(db.Integer) # position of player at the table
game_id = db.Column(db.Integer, db.ForeignKey("games.id"), nullable=True)
game = db.relationship("Game",
foreign_keys=[game_id],
backref="game_players")
player_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
player = db.relationship("User",
foreign_keys=[player_id],
backref="user_players")
cards = db.relationship("Card", back_populates="player")
messages = db.relationship("Message", back_populates="player")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class Game(db.Model):
__tablename__ = "games"
id = db.Column(db.Integer, primary_key=True)
game_type_id = db.Column(db.Integer,
db.ForeignKey("game_types.id"),
nullable=True)
game_type = db.relationship("GameType",
foreign_keys=[game_type_id],
backref="gametype_games")
game_status = db.Column(db.Integer) # 0: waiting, 1: playing, 2: completed
pot = db.Column(db.Integer)
current_turn = db.Column(db.Integer)
starting_turn = db.Column(db.Integer)
current_bet = db.Column(db.Integer)
betting = db.Column(
db.Boolean, unique=False,
default=False) # 0: done with betting round, # 1: betting round
round_num = db.Column(db.Integer) # number of rounds of cards dealt
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class Walk(db.Model):
id = db.Column(db.Integer, primary_key=True)
planned_by_user_id = db.Column(db.Integer)
location = db.Column(db.String(255))
date = db.Column(db.String(255))
time = db.Column(db.String(255))
dogs = db.Column(db.String(255))
walk_info = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
users_on_this_walk = db.relationship('User',
secondary=users_and_walks,
backref='user_joins_walks',
cascade='all')
@classmethod
def validate_new_walk(cls, validate_new_walk):
is_valid = True
if len(validate_new_walk["location"]) < 1:
is_valid = False
flash(
"Location cannot be less than 1 character in length. Try again."
)
if validate_new_walk["walk_date"] == "":
is_valid = False
flash("Walk date missing.")
elif validate_new_walk["walk_date"] < str(datetime.today()):
is_valid = False
flash(
"This walk can't be created in the past or on today's date. Please create a walk starting with tomorrow's date."
)
if validate_new_walk["walk_time"] == "":
is_valid = False
flash("Please enter a time.")
if len(validate_new_walk["dogs"]) < 1:
is_valid = False
flash("You can't create a walk without dogs!")
return is_valid
@classmethod
def add_walk(cls, add_walk_data):
add_walk = cls(
planned_by_user_id=add_walk_data["user_id"],
location=add_walk_data["location"],
# date = datetime.strptime(add_walk_data["walk_date"], '%Y-%m-%d').strftime('%m-%d-%Y'),
date=add_walk_data["walk_date"],
time=datetime.strptime(add_walk_data["walk_time"],
'%H:%M').strftime('%I:%M %p'),
dogs=add_walk_data["dogs"],
walk_info=add_walk_data["walk_info"])
db.session.add(add_walk)
db.session.commit()
flash("You created a walk!")
return add_walk
@classmethod
def edit_walk(cls, edit_walk_data):
edit_walk = Walk.query.get(edit_walk_data["edit_walk_value"])
edit_walk.location = edit_walk_data["location"]
edit_walk.date = edit_walk_data["walk_date"]
edit_walk.time = datetime.strptime(edit_walk_data["walk_time"],
'%H:%M').strftime('%I:%M %p')
edit_walk.dogs = edit_walk_data["dogs"]
edit_walk.walk_info = edit_walk_data["walk_info"]
db.session.add(edit_walk)
db.session.commit()
flash("Walk Information Updated")
return edit_walk
@classmethod
def cancel_walk(cls, cancel_walk_data):
cancel_walk = Walk.query.filter(
Walk.id == cancel_walk_data["cancelled_walk_value"]).delete()
db.session.commit()
flash("You cancelled this walk!")
return cancel_walk
class customer(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255))
phone_number = db.Column(db.String(255))
password = db.Column(db.String(60))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
@classmethod
def validate_customer(cls, new_customer_data):
is_valid = True
if len(new_customer_data["first_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_customer_data["first_name"]):
is_valid = False
flash("Please enter a valid first name.")
if len(new_customer_data["last_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_customer_data["last_name"]):
is_valid = False
flash(
"Please enter a valid last name. Must be between 3-20 characters in length and contain no numbers or special characters."
)
if len(new_customer_data["email"]) < 1 or not re.search(
"[^@]+@[^@]+\.[^@]+", new_customer_data["email"]):
is_valid = False
flash("Please enter a valid email address.")
if len(new_customer_data["phone_number"]) < 1 or not re.search(
"^(\([0-9]{3}\) |[0-9]{3}-)[0-9]{3}-[0-9]{4}$",
new_customer_data["phone_number"]):
is_valid = False
flash("Please enter a valid phone number.")
if len(new_customer_data["password"]) < 8:
is_valid = False
flash(
"Password should be at least 8 characters and contain one number and uppercase letter"
)
if new_customer_data["confirm_password"] != new_customer_data[
"password"]:
is_valid = False
flash("Passwords do not match!")
return is_valid
@classmethod
def add_new_customer(cls, new_customer_data):
add_customer = cls(first_name=new_customer_data["first_name"],
last_name=new_customer_data["last_name"],
email=new_customer_data["email"],
phone_number=new_customer_data["phone_number"],
password=bcrypt.generate_password_hash(
new_customer_data["password"]))
db.session.add(add_customer)
db.session.commit()
flash("Registration successful! Log in to continue.")
return add_customer
@classmethod
def validate_edit_customer(cls, new_customer_data):
is_valid = True
if len(new_customer_data["first_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_customer_data["first_name"]):
is_valid = False
flash("Please enter a valid first name.")
if len(new_customer_data["last_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_customer_data["last_name"]):
is_valid = False
flash(
"Please enter a valid last name. Must be between 3-20 characters in length and contain no numbers or special characters."
)
if len(new_customer_data["phone_number"]) < 1 or not re.search(
"^(\([0-9]{3}\) |[0-9]{3}-)[0-9]{3}-[0-9]{4}$",
new_customer_data["phone_number"]):
is_valid = False
flash("Please enter a valid phone number.")
return is_valid
@classmethod
def edit_customer(cls, edit_customer_data):
edit_customer = customer.query.get(edit_customer_data["login_id"])
edit_customer.first_name = edit_customer_data["first_name"]
edit_customer.last_name = edit_customer_data["last_name"]
edit_customer.phone_number = edit_customer_data["phone_number"]
db.session.commit()
flash("Customer Information Updated")
return edit_customer
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
date_of_birth = db.Column(db.String(255))
phone_number = db.Column(db.String(255))
password = db.Column(db.String(60))
image = db.Column(db.String(500))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
user_joined_walk = db.relationship('Walk',
secondary=users_and_walks,
backref='users_on_walk',
cascade='all')
@classmethod
def validate_user(cls, new_user_data):
is_valid = True
if len(new_user_data["first_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_user_data["first_name"]):
is_valid = False
flash("Please enter a valid first name.")
if len(new_user_data["last_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_user_data["last_name"]):
is_valid = False
flash(
"Please enter a valid last name. Must be between 3-20 characters in length and contain no numbers or special characters."
)
if len(new_user_data["email"]) < 1 or not re.search(
"[^@]+@[^@]+\.[^@]+", new_user_data["email"]):
is_valid = False
flash(
"Please enter a valid email address containing @ AND . followed by com/org/etc."
)
if len(new_user_data["phone_number"]) < 1 or not re.search(
"^(\([0-9]{3}\) |[0-9]{3}-)[0-9]{3}-[0-9]{4}$",
new_user_data["phone_number"]):
is_valid = False
flash("Please enter a valid phone number.")
if new_user_data["confirm_password"] != new_user_data["password"]:
is_valid = False
flash("Passwords do not match!")
try:
birthday = datetime.strptime(new_user_data["birthday"], "%Y-%m-%d")
diff = datetime.now() - birthday
if int(diff.total_seconds()) < 56764800:
is_valid = False
flash("You must be 18 years old or older to register!")
except:
is_valid = False
flash("Please enter a valid birthday.")
return is_valid
@classmethod
def add_new_user(cls, new_user_data):
add_user = cls(first_name=new_user_data["first_name"],
last_name=new_user_data["last_name"],
email=new_user_data["email"],
phone_number=new_user_data["phone_number"],
date_of_birth=new_user_data["birthday"],
password=bcrypt.generate_password_hash(
new_user_data["password"]),
image="static/img/default_img.jpg")
db.session.add(add_user)
db.session.commit()
flash(
"User successfully added! Login to view the Dog Buddy Dashboard!")
return add_user
@classmethod
def edit_user(cls, edit_user_data):
edit_user = User.query.get(edit_user_data["login_id"])
edit_user.first_name = edit_user_data["first_name"]
edit_user.last_name = edit_user_data["last_name"]
edit_user.email = edit_user_data["email"]
edit_user.date_of_birth = edit_user_data["birthday"]
edit_user.phone_number = edit_user_data["phone_number"]
edit_user.password = bcrypt.generate_password_hash(
edit_user_data["password"])
db.session.commit()
flash("User Information Updated")
return edit_user
class Dog(db.Model):
id = db.Column(db.Integer, primary_key=True)
owner_id = db.Column(db.Integer)
dog_name = db.Column(db.String(255))
breed = db.Column(db.String(255))
age = db.Column(db.String(255))
gender = db.Column(db.String(255))
eye_color = db.Column(db.String(255))
fur_color = db.Column(db.String(255))
fur_type = db.Column(db.String(255))
allergies = db.Column(db.String(255))
brief_bio = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
# user_with_dog = db.relationship('User', backref='Dog', cascade='all')
@classmethod
def validate_dog(cls, new_dog_data):
is_valid = True
if len(new_dog_data["dog_name"]) < 1:
is_valid = False
flash("Please enter a valid dog name.")
if len(new_dog_data["breed"]) < 1:
is_valid = False
flash("Please enter a valid breed.")
if len(new_dog_data["age"]) < 0:
is_valid = False
flash("Please enter a valid dog age.")
if len(new_dog_data["eye_color"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_dog_data["eye_color"]):
is_valid = False
flash("Please enter a valid dog eye color.")
if len(new_dog_data["fur_color"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_dog_data["fur_color"]):
is_valid = False
flash("Please enter a valid dog fur color.")
if len(new_dog_data["fur_type"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_dog_data["fur_type"]):
is_valid = False
flash("Please enter a valid fur type.")
if len(new_dog_data["allergies"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_dog_data["allergies"]):
is_valid = False
flash("Please enter a valid dog allergies.")
if len(new_dog_data["brief_bio"]) < 1 or len(
new_dog_data["brief_bio"]) > 255:
is_valid = False
flash("Please enter a valid dog bio.")
return is_valid
@classmethod
def add_dog(cls, new_dog_data):
add_dog = cls(owner_id=new_dog_data["user_id"],
dog_name=new_dog_data["dog_name"],
breed=new_dog_data["breed"],
age=new_dog_data["age"],
gender=new_dog_data["gender"],
eye_color=new_dog_data["eye_color"],
fur_color=new_dog_data["fur_color"],
fur_type=new_dog_data["fur_type"],
allergies=new_dog_data["allergies"],
brief_bio=new_dog_data["brief_bio"])
db.session.add(add_dog)
db.session.commit()
flash(new_dog_data["dog_name"] + " successfully added!")
return add_dog
@classmethod
def edit_dog(cls, edit_dog_data):
edit_dog = Dog.query.get(edit_dog_data["dog_id"])
edit_dog.name = edit_dog_data["dog_name"]
edit_dog.breed = edit_dog_data["breed"]
edit_dog.age = edit_dog_data["age"]
edit_dog.gender = edit_dog_data["gender"]
edit_dog.eye_color = edit_dog_data["eye_color"]
edit_dog.fur_color = edit_dog_data["fur_color"]
edit_dog.fur_type = edit_dog_data["fur_type"]
edit_dog.allergies = edit_dog_data["allergies"]
edit_dog.brief_bio = edit_dog_data["brief_bio"]
db.session.commit()
flash(edit_dog.name + "'s Information Was Updated")
return edit_dog
@classmethod
def delete_dog(cls, delete_dog_data):
delete_dog_name = delete_dog_data["dog_name"]
delete_dog = Dog.query.filter(
Dog.id == delete_dog_data["dog_id"]).delete()
db.session.commit()
flash("Information About " + delete_dog_name + " Deleted")
return delete_dog
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(60))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
@classmethod
def validate_user(cls, new_user_data):
is_valid = True
if len(new_user_data["first_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_user_data["first_name"]):
is_valid = False
flash("Please enter a valid first name.")
if len(new_user_data["last_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", new_user_data["last_name"]):
is_valid = False
flash("Please enter a valid last name.")
if len(new_user_data["email"]) < 1 or not re.search(
"[^@]+@[^@]+\.[^@]+", new_user_data["email"]):
is_valid = False
flash(
"Please enter a valid email address containing @ AND . followed by com/org/etc."
)
if len(new_user_data["password"]) < 8:
is_valid = False
flash("Password should be at least 8 characters.")
if new_user_data["confirm_password"] != new_user_data["password"]:
is_valid = False
flash("Passwords do not match!")
return is_valid
@classmethod
def add_new_user(cls, new_user_data):
add_user = cls(first_name=new_user_data["first_name"],
last_name=new_user_data["last_name"],
email=new_user_data["email"],
password=bcrypt.generate_password_hash(
new_user_data["password"]))
db.session.add(add_user)
db.session.commit()
flash(
"User successfully added! Login to view the Quote Dash Dashboard!")
return add_user
@classmethod
def validate_edit_user(cls, edit_user_data):
is_valid = True
if len(edit_user_data["edit_first_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", edit_user_data["edit_first_name"]):
is_valid = False
flash("Please enter a valid first name.")
if len(edit_user_data["edit_last_name"]) < 1 or re.search(
"[^a-zA-ZäöüßÄÖÜ]", edit_user_data["edit_last_name"]):
is_valid = False
flash("Please enter a valid last name.")
if len(edit_user_data["edit_email"]) < 1 or (
edit_user_data["edit_email"]
== edit_user_data["edit_email"]) or not re.search(
"[^@]+@[^@]+\.[^@]+", edit_user_data["edit_email"]):
is_valid = False
return is_valid
@classmethod
def edit_user(cls, edit_user_data):
user_instance_to_update = User.query.get(edit_user_data["login_id"])
print(user_instance_to_update)
user_instance_to_update.first_name = edit_user_data["edit_first_name"]
user_instance_to_update.last_name = edit_user_data["edit_last_name"]
user_instance_to_update.email = edit_user_data["edit_email"]
db.session.commit()
flash("Updated account information successful!")
return user_instance_to_update
import re
app.secret_key = 'secret'
bcrypt = Bcrypt(app)
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
PASSWORD_REGEX = re.compile(r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!#%*?&]{5,}$')
SpecialSym =['$', '@', '#', '%']
expenses = db.Table('expenses',
db.Column('id', db.Integer, primary_key=True),
db.Column('todo_id', db.Integer, default=0),
db.Column('user_id', db.Integer, db.ForeignKey('users.id', ondelete='cascade', onupdate='cascade')),
db.Column('category_id', db.Integer, db.ForeignKey('categories.id', ondelete='cascade', onupdate='cascade')),
db.Column('amount', db.Float),
db.Column('content', db.String),
db.Column('created_at', db.DateTime, server_default=func.now()),
db.Column('updated_at', db.DateTime, server_default=func.now(), onupdate=func.now()))
todos = db.Table('todos',
db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer, db.ForeignKey('users.id', ondelete='cascade', onupdate='cascade')),
db.Column('category_id', db.Integer, db.ForeignKey('categories.id', ondelete='cascade', onupdate='cascade')),
db.Column('amount', db.Float),
db.Column('content', db.String(255)),
db.Column('is_done', db.Boolean),
db.Column('created_at', db.DateTime, server_default=func.now()),
db.Column('updated_at', db.DateTime, server_default=func.now(), onupdate=func.now()))
class UserExpense(db.Model):
__tablename__ = 'expenses'
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(45))
last_name = db.Column(db.String(45))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
monthly_income = db.Column(db.Float)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
user_expenses = db.relationship('UserExpense', lazy=True,backref=db.backref('expenses_author'))
user_todos = db.relationship('UserTodo',lazy=True,backref=db.backref('todos_author'))
@classmethod
def validate_user(cls, user_data):
is_valid = True
first_name = user_data["first_name"]
last_name = user_data['last_name']
passwd = user_data['password']
if len(first_name) < 1:
is_valid = False
flash(u'First name cannot be blank.', 'first_name')
if len(last_name) < 1:
is_valid = False
flash(u'Last name cannot be blank.', 'last_name')
if (not first_name.isalpha() or not last_name.isalpha()) and len(first_name) > 0 and len(last_name) > 0:
is_valid = False
flash("First name and last name should contains only letters")
if len(request.form['email']) < 1:
flash("Email cannot be blank!", 'email')
if not EMAIL_REGEX.match(request.form['email']) and len(request.form['email']) > 0: # test whether a field matches the pattern
is_valid = False
flash("Invalid email address!", 'email')
if len(user_data["monthly_income"]) < 1:
is_valid = False
flash('Monthly income cannot be null','monthly_income')
if not user_data["monthly_income"].isdigit():
is_valid = False
flash('Monthly income must be a number','monthly_income')
if not PASSWORD_REGEX.match(request.form['password'] ):
is_valid = False
flash("Password must have at least 5 characters, one number, one uppercase character, one special symbol.",'password')
if request.form['password'] != request.form['confirm_password']:
is_valid = False
flash("Password doesn't match", 'password')
return is_valid
@classmethod
def add_new_user(cls, user_data):
hashed_password = bcrypt.generate_password_hash(user_data["password"]).decode('utf-8')
user_to_add = cls(first_name=user_data["first_name"], last_name=user_data["last_name"], email=user_data["email"], password=hashed_password)
db.session.add(user_to_add)
db.session.commit()
return user_to_add
@classmethod
def validate_on_login(cls, user_data):
# result = User.query.filter_by(email=user_data['email']).first_or_404(description="Email doesn't exists")
is_valid = True
if len(user_data['email']) < 1:
is_valid = False
flash('Email cannot be blank','email')
if len(user_data['password']) <1:
is_valid = False
flash('Passoword cannot be blank','password')
if is_valid :
user = User.query.filter_by(email=user_data['email']).first()
if user:
if not bcrypt.check_password_hash(user.password, user_data['password']):
is_valid = False
flash('Invalid email or password.','login_error')
return is_valid
return age
class Follow(db.Model):
__tablename__ = "follows"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user1 = db.relationship("User", backref="likes", cascade="all")
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user2 = db.relationship("User", backref="likes", cascade="all")
created_at = db.Column(db.DateTime, server_default=func.now())
likes_table = db.Table(
'likes', db.Column('tweet_id',
db.ForeignKey('tweets.id'),
primary_key=True),
db.Column('user_id', db.ForeignKey('users.id'), primary_key=True))
db.Column('created_at', db.DateTime, server_default=func.now())
followers_table = db.Table(
'followers',
db.Column("follower_id",
db.Integer,
db.ForeignKey("users.id"),
primary_key=True),
db.Column("followed_id",
db.Integer,
db.ForeignKey("users.id"),
primary_key=True),
db.Column("created_at", db.DateTime, server_default=func.now()))
