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()))