class User_Model(db.Model):
__tablename__ = 'users'
user_id = db.Column(db.String, primary_key=True)
pref_name = db.Column(db.String, nullable=False)
class User(db.Model):
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(45))
password = db.Column(db.String(60))
quotes_this_user_liked = db.relationship('Quote', secondary=user_like_table)
created_at = db.Column(db.DateTime, server_default=func.now()) # notice the extra import statement above
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
@classmethod
def validate_user(cls, user_data):
is_valid = True
if not EMAIL_REGEX.match(user_data['email']): # test whether a field matches the pattern
is_valid = False
# display error message
flash("Invalid email address!")
if len(user_data['first_name']) < 1:
is_valid = False
# display error message
flash("please enter first name")
if len(user_data['last_name']) < 1:
is_valid = False
# display error message
flash("please enter last name")
if user_data['first_name'].replace(' ','',1).strip().isalpha() == False:
is_valid = False
# display error message
flash("please use only letters in the first name text field")
if user_data['last_name'].replace(' ','',1).strip().isalpha() == False:
is_valid = False
# display error message
flash("please use only letters in the last name text field")
if len(user_data['email']) < 1:
is_valid = False
# display error message
flash("please enter an email")
if len(user_data['password']) < 1:
is_valid = False
# display error message
flash("please enter a password")
if len(user_data['password']) < 5:
is_valid = False
# display error message
flash("your password needs to be at least 5 characters in length")
if user_data['password'] != user_data['confirm_password']:
is_valid = False
# display error message
flash("confirm password and password need to be the same")
return is_valid
@classmethod
def update_user(cls, user_data):
is_valid = True
if not EMAIL_REGEX.match(user_data['email']): # test whether a field matches the pattern
is_valid = False
# display error message
flash("Invalid email address!")
if len(user_data['first_name']) < 1:
is_valid = False
# display error message
flash("please enter first name")
if len(user_data['last_name']) < 1:
is_valid = False
# display error message
flash("please enter last name")
if user_data['first_name'].replace(' ','',1).strip().isalpha() == False:
is_valid = False
# display error message
flash("please use only letters in the first name text field")
if user_data['last_name'].replace(' ','',1).strip().isalpha() == False:
is_valid = False
# display error message
flash("please use only letters in the last name text field")
if len(user_data['email']) < 1:
is_valid = False
# display error message
flash("please enter an email")
return is_valid
class Set(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column('name', db.String(100), unique=True)
tag = db.Column('tag', db.String(100))
images = db.relationship('Images', backref="set", passive_deletes=True, lazy="dynamic")
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))
class EodPrices(db.Model):
date = db.Column(db.String(80))
symbol = db.Column(db.String(80))
close = db.Column(db.Float(), unique=True)
high = db.Column(db.Float(), unique=True)
low = db.Column(db.Float(), unique=True)
open = db.Column(db.Float(), unique=True)
volume = db.Column(db.BigInt(), unique=True)
adjClose = db.Column(db.Float(), unique=True)
adjHigh = db.Column(db.Float(), unique=True)
adjLow = db.Column(db.Float(), unique=True)
adjVolume = db.Column(db.BigInt(), unique=True)
divCash = db.Column(db.Float(), unique=True)
splitFactor = db.Column(db.Float(), unique=True)
def __init__(self, date, symbol, close, high, low, open, volume, adjClose,
adjHigh, adjLow, adjVolume, divCash, splitFactor):
self.date = date
self.symbol = symbol
self.close = close
self.high = high
self.low = low
self.open = open
self.volume = volume
self.adjClose = adjClose
self.adjHigh = adjHigh
self.adjLow = adjLow
self.adjVolume = adjVolume
self.divCash = divCash
self.splitFactor = splitFactor
def __repr(self):
return '<date %r>' % self.date
class Users(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(), unique=True, nullable=False)
password = db.Column(db.String(), nullable=False)
found_messages = db.relationship(MessagesFound, backref=db.backref('user'))
class ItemsOwned(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
item_id = db.Column(db.Integer, db.ForeignKey('items.id'))
class CareerProjection(db.Model):
__tablename__ = "careerProjection"
occupation_title = db.Column(db.String(64))
soc_code = db.Column(db.String(32), primary_key=True)
employment_2016_thousands = db.Column(db.Float)
employment_2026_thousands = db.Column(db.Float)
employment_change_thousands_2026 = db.Column(db.Float)
employment_change_percent_2026 = db.Column(db.Float)
openings = db.Column(db.Float)
median_wage = db.Column(db.Integer)
entry_level_education = db.Column(db.String(64))
work_experience_related = db.Column(db.String(64))
on_the_job_training = db.Column(db.String(64))
class Post(db.Model):
__tablename__ = "post"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text, nullable=False)
content = db.Column(db.Text)
price = db.Column(db.Float, nullable=False)
address = db.Column(db.String(70), nullable=False)
bairro = db.Column(db.String(40), nullable=False)
cep = db.Column(db.String(9), nullable=False)
city = db.Column(db.String(40), nullable=False)
state = db.Column(db.String(40), nullable=False)
image = db.Column(db.Text, nullable=False, default=False)
n_casa = db.Column(db.String(7), nullable=False)
referencia = db.Column(db.String(40), nullable=False)
mora_local = db.Column(db.Boolean, nullable=False, default=False)
restricao_sexo = db.Column(db.String(1), nullable=False)
pessoas_no_local = db.Column(db.Integer, nullable=False)
mobiliado = db.Column(db.Boolean, nullable=False, default=False)
comoditie = db.relationship('Comoditie',
backref='Post',
lazy=True,
uselist=False)
favorite = db.relationship('User_has_Post_as_favorite',
backref='Post',
lazy=True)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
title_filter = db.Column(db.Text, nullable=False, default='quarto')
# id do usuário que criou essa tabela, tem que ser igual da class User
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __init__(self, title, content, price, address, bairro, cep, city,
state, image, n_casa, referencia, mora_local, restricao_sexo,
pessoas_no_local, mobiliado, title_filter, author):
self.title = title
self.content = content
self.price = price
self.address = address
self.bairro = bairro
self.cep = cep
self.city = city
self.state = state
self.image = image
self.n_casa = n_casa
self.referencia = referencia
self.mora_local = mora_local
self.restricao_sexo = restricao_sexo
self.pessoas_no_local = pessoas_no_local
self.mobiliado = mobiliado
self.title_filter = title_filter
self.user_id = author
def __repr__(self):
return f"Post('{self.id}','{self.title}')"
class Category(db.Model):
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(125), nullable=False)
category_products = db.relationship('Product', backref='product_cat')
class chongqing_data(db.Model):
__tablename__ = "chongqing"
id = db.Column(db.INTEGER, primary_key=True)
txt = db.Column(db.String)
url = db.Column(db.String)
class Users(db.Model):
# f__tablename__ = "users" # optional
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(145))
email = db.Column(db.String(125))
password = db.Column(db.String(125))
user_purchases = db.relationship('Purchases', backref='owner')
# user_likes = db.relationship('Likes', backref='user_liked')
created_at = db.Column(
db.DateTime,
server_default=func.now()) # notice the extra import statement above
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
@classmethod
def validate_user(cls, user_data):
is_valid = True
if len(user_data["name"]) < 1:
is_valid = False
flash("Please provide name")
# if len(user_data["alias"]) < 1:
# is_valid = False
# flash("Please provide alias")
if not EMAIL_REGEX.match(user_data["email"]):
is_valid = False
flash("Please provide a valid email")
if len(user_data["password"]) < 8:
is_valid = False
flash("Password must be at least 8 characters")
if user_data["password"] != user_data["cpassword"]:
is_valid = False
flash("Passwords do not match")
return is_valid
@classmethod
def validate_login(cls, user_data):
print(user_data)
is_valid = True
result = Users.query.filter_by(email=user_data["username"]).first()
if not EMAIL_REGEX.match(user_data["username"]):
is_valid = False
flash("Please provide a valid email")
if len(user_data["password"]) < 3:
is_valid = False
flash("Password should be at least 8 characters")
if result:
if not bcrypt.check_password_hash(result.password,
user_data['password']):
is_valid = False
flash("Passwords incorrect")
return is_valid
@classmethod
def add_new_user(cls, user_data):
hashed_password = bcrypt.generate_password_hash(user_data["password"])
user_to_add = cls(name=user_data["name"],
email=user_data["email"],
password=hashed_password)
db.session.add(user_to_add)
db.session.commit()
return user_to_add
@classmethod
def add_new_user(cls, user_data):
hashed_password = bcrypt.generate_password_hash(user_data["password"])
user_to_add = cls(name=user_data["name"],
email=user_data["email"],
password=hashed_password)
db.session.add(user_to_add)
db.session.commit()
return user_to_add
################################################ Product_purchases Table ########################################################
Product_purchases = db.Table(
'product_purchases',
db.Column('product_id', db.Integer, db.ForeignKey('product.id')),
db.Column('purchase_id', db.Integer, db.ForeignKey('purchases.id')),
db.Column('number_of_items', db.Integer), db.Column('amount', db.Float))
################################################ Product Table ########################################################
class Product(db.Model):
# f__tablename__ = "users" # optional
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(145))
price = db.Column(db.Float)
cat_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(),
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False, unique=True)
description = db.Column(db.String(300), nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
class Indicators(db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
indicator = db.Column(db.String(500), unique=True)
date_created = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
last_seen = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
last_updated = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
indicator_type = db.Column(db.String(1000))
#diamond_model = db.Column(db.String(1000))
#kill_chain = db.Column(db.String(1000))
#confidence = db.Column(db.String(1000))
# ipinfo.io Enrichment
ipinfo_hostname = db.Column(db.String(100))
ipinfo_city = db.Column(db.String(1000))
ipinfo_region = db.Column(db.String(1000))
ipinfo_postal = db.Column(db.String(1000))
ipinfo_country = db.Column(db.String(1000))
ipinfo_org = db.Column(db.String(1000))
# ATT&CK Enrichment
attack_name = db.Column(db.String(1000))
attack_permissionsrequired = db.Column(db.String(1000))
attack_description = db.Column(db.String(1000))
attack_platforms = db.Column(db.String(1000))
attack_detection = db.Column(db.String(1000))
attack_killchain = db.Column(db.String(1000))
# Domain WHOIS Enrichment
whois_registrar = db.Column(db.String(1000))
whois_creationdate = db.Column(db.String(1000))
whois_expirationdate = db.Column(db.String(1000))
whois_lastupdated = db.Column(db.String(1000))
whois_nameservers = db.Column(db.String(1000))
# VirusTotal Enrichment
vt_scan_date = db.Column(db.String(1000))
vt_positives = db.Column(db.String(1000))
# Emailrep Enrichment
emailrep_reputation= db.Column(db.String(1000))
emailrep_suspicious = db.Column(db.String(1000))
emailrep_references = db.Column(db.String(1000))
emailrep_blacklisted= db.Column(db.String(1000))
emailrep_maliciousactivity = db.Column(db.String(1000))
emailrep_credsleaked = db.Column(db.String(1000))
emailrep_databreach = db.Column(db.String(1000))
emailrep_first_seen = db.Column(db.String(1000))
emailrep_last_seen = db.Column(db.String(1000))
emailrep_domain_rep = db.Column(db.String(1000))
emailrep_profiles = db.Column(db.String(1000))
# AlienVault OTX Enrichment
av_reputation = db.Column(db.String(1000))
av_malware_data = db.Column(db.String(100000))
av_url_data = db.Column(db.String(100000))
av_passive_data = db.Column(db.String(100000))
av_general = db.Column(db.String(1000000))
av_pulse_count = db.Column(db.String(1000000))
av_tlp = db.Column(db.String(1000000))
# Shodan Enrichment
shodan_tags = db.Column(db.String(100000))
shodan_region = db.Column(db.String(100000))
shodan_postal = db.Column(db.String(100000))
shodan_country = db.Column(db.String(100000))
shodan_city = db.Column(db.String(100000))
shodan_ports = db.Column(db.String(100000))
shodan_hostnames = db.Column(db.String(100000))
shodan_org = db.Column(db.String(100000))
# Urlscan.io
urlscan_categories = db.Column(db.String(100000))
urlscan_tags = db.Column(db.String(100000))
urlscan_score = db.Column(db.String(100000))
urlscan_malicious = db.Column(db.String(100000))
# RiskIQ
risk_classifications=db.Column(db.String(100000))
risk_sinkhole = db.Column(db.String(100000))
risk_evercompromised = db.Column(db.String(100000))
risk_primarydomain = db.Column(db.String(100000))
risk_subdomains = db.Column(db.String(100000))
risk_tags = db.Column(db.String(100000))
risk_dynamicdns = db.Column(db.String(100000))
risk_sources = db.Column(db.String(100000))
# Greynoise
gn_seen = db.Column(db.String(100000))
gn_classification = db.Column(db.String(100000))
gn_first_seen = db.Column(db.String(100000))
gn_last_seen = db.Column(db.String(100000))
gn_actor = db.Column(db.String(100000))
gn_tags = db.Column(db.String(100000))
# CIRCL CVE-SEARCH
vuln_cvss = db.Column(db.String(100000))
vuln_references = db.Column(db.String(100000))
vuln_summary = db.Column(db.String(100000))
vuln_published = db.Column(db.String(100000))
vuln_modified = db.Column(db.String(100000))
# MISP
misp_eventid = db.Column(db.String(100000))
misp_firstseen = db.Column(db.String(100000))
misp_lastseen = db.Column(db.String(100000))
misp_eventinfo = db.Column(db.String(100000))
misp_dateadded = db.Column(db.String(100000))
misp_comment = db.Column(db.String(100000))
#HIBP
hibp_breaches = db.Column(db.String(100000))
#Hunter
hunter_result = db.Column(db.String(100000))
hunter_score = db.Column(db.String(100000))
hunter_disposable = db.Column(db.String(100000))
hunter_webmail = db.Column(db.String(100000))
hunter_mx_records = db.Column(db.String(100000))
hunter_smtp_server = db.Column(db.String(100000))
hunter_smtp_check = db.Column(db.String(100000))
hunter_blocked = db.Column(db.String(100000))
class Artist(db.Model):
__tablename__ = 'artists'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
city = db.Column(db.String(120), nullable=False)
state = db.Column(db.String(120), nullable=False)
phone = db.Column(db.String(120), nullable=True)
genres = db.Column(db.String(120), nullable=False)
seeking_venue = db.Column(db.Boolean, nullable=False)
seeking_description = db.Column(db.String(), nullable=True)
image_link = db.Column(db.String(500), nullable=False)
facebook_link = db.Column(db.String(120), nullable=True)
created = db.Column(db.DateTime)
website = db.Column(db.String(120), nullable=True)
shows = db.relationship('Show',
backref='artist',
lazy=True,
cascade='all, delete')
busy_times = db.relationship('BusyTime',
backref='artist',
lazy=True,
cascade='all, delete')
from flask import flash, session
from sqlalchemy.sql import func
from config import db, EMAIL_REGEX, bcrypt
muscles_exercises_table = db.Table('muscles_exercises_relationship',
db.Column('muscles_id', db.Integer, db.ForeignKey('muscles.id'), primary_key=True),
db.Column('exercises_id', db.Integer, db.ForeignKey('exercises.id'), primary_key=True))
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(45))
last_name = db.Column(db.String(45))
username = db.Column(db.String(45))
email = db.Column(db.String(75))
password = db.Column(db.String(30))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now())
@classmethod
def validate_user(cls, user_data):
is_valid = True
if len(user_data['first_name']) < 1:
is_valid = False
flash("Enter a First Name")
if len(user_data['last_name']) < 1:
is_valid = False
flash("Enter a Last Name")
if len(user_data['username']) < 1:
is_valid = False
flash("Enter a Username")
if not EMAIL_REGEX.match(user_data['email']):
class NatPro(db.Model):
__tablename__ = "natpro"
id = db.Column(db.Integer, primary_key=True)
region = db.Column(db.String(255))
yoy_growth = db.Column(db.String(255))
class Items(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), unique=True)
class Requirements(db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
friendly_id = db.Column(db.String(100), unique=True)
title = db.Column(db.String(500))
owner = db.Column(db.String(100))
priority = db.Column(db.String(100))
summary = db.Column(db.String(10000))
gaps = db.Column(db.String(10000))
collection_requirements = db.Column(db.String(10000))
deliverables = db.Column(db.String(10000))
time_requirement = db.Column(db.Date())
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
creator = db.Column(db.String(100))
is_archived = db.Column(db.Boolean, default=False)
class MessagesFound(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
message_id = db.Column(db.Integer, db.ForeignKey('messages.id'))
class ReportTags(db.Model):
report = db.Column(db.Integer, db.ForeignKey('reports.id'), primary_key=True)
tag = db.Column(db.String(100), nullable=False, primary_key=True)
class Tweet(db.Model):
id = db.Column(db.Integer, primary_key=True)
tweet_content = db.Column(db.String(255))
users_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
users_who_like_this_tweet = db.relationship('User', secondary=likes_table)
class RequirementConsumers(db.Model):
consumer = db.Column(db.Integer, db.ForeignKey('consumers.id'), primary_key=True)
requirement = db.Column(db.Integer, db.ForeignKey('requirements.id'), primary_key=True)
from flask import flash
from sqlalchemy.sql import func
from config import db, re
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
user_like_table = db.Table('likes_user',
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
db.Column('quote_id', db.Integer, db.ForeignKey('quote.id'), primary_key=True),)
class Quote(db.Model):
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String(45))
quote = db.Column(db.String(255))
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
user = db.relationship('User', foreign_keys=[user_id], backref="user_quote", cascade="all")
user_who_liked_this_quote = db.relationship('User', secondary=user_like_table)
created_at = db.Column(db.DateTime, server_default=func.now()) # notice the extra import statement above
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
@classmethod
def validate_quote(cls, quote_data):
is_valid = True
if len(quote_data['author']) < 3:
is_valid = False
# display error message
flash("please enter Author name that is longer than 3 characters")
if len(quote_data['quote']) < 10:
is_valid = False
# display error message
flash("The quote needs to be larger than 10 characters")
return is_valid
class RequirementReports(db.Model):
requirement = db.Column(db.Integer, db.ForeignKey('requirements.id'), primary_key=True)
report = db.Column(db.Integer, db.ForeignKey('reports.id'), primary_key=True)
class Info(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column('name', db.String(90))
content = db.Column('content', db.Text())
class Organization(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), unique=True)
org_key =db.Column(db.String(100), unique=True)# some key for new users to register wth
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
whois_enabled = db.Column(db.Boolean, default=True)
ipinfo_enabled = db.Column(db.Boolean, default=True)
vt_enabled = db.Column(db.Boolean, default=False)
vt_api_key = db.Column(db.String(1000))
shodan_enabled = db.Column(db.Boolean, default=False)
shodan_api_key = db.Column(db.String(1000))
urlscan_enabled = db.Column(db.Boolean, default=False)
urlscan_api_key = db.Column(db.String(1000))
emailrep_enabled = db.Column(db.Boolean, default=False)
emailrep_api_key = db.Column(db.String(1000))
riskiq_enabled = db.Column(db.Boolean, default=False)
riskiq_username = db.Column(db.String(50))
riskiq_api_key = db.Column(db.String(50))
gn_enabled = db.Column(db.Boolean, default=False)
gn_api_key = db.Column(db.String(50))
av_enabled = db.Column(db.Boolean, default=False)
av_api_key = db.Column(db.String(100))
misp_enabled = db.Column(db.Boolean, default=False)
misp_api_key = db.Column(db.String(100))
misp_url = db.Column(db.String(1000))
hibp_api_key = db.Column(db.String(100))
hibp_enabled = db.Column(db.Boolean, default=False)
hunter_api_key = db.Column(db.String(100))
hunter_enabled = db.Column(db.Boolean, default=False)
slack_webhook = db.Column(db.String(1000))
slack_webhook_on_report_create = db.Column(db.Boolean, default=False)
slack_webhook_on_req_create = db.Column(db.Boolean, default=False)
slack_webhook_on_req_update = db.Column(db.Boolean, default=False)
class Images(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column('name', db.String(100))
set_id = db.Column(db.Integer, db.ForeignKey('set.id', ondelete='CASCADE'))
class Artist(db.Model):
__tablename__ = 'artist'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
city = db.Column(db.String(120), nullable=False)
state = db.Column(db.String(120), nullable=False)
phone = db.Column(db.String(120), nullable=False)
genres = db.Column(db.String(120), nullable=False)
image_link = db.Column(db.String(500))
facebook_link = db.Column(db.String(120))
website = db.Column(db.String(120))
seeking_venue = db.Column(db.Boolean)
seeking_description = db.Column(db.String(500))
shows = db.relationship('Show',
backref='artist',
primaryjoin=id == Show.artist_id)
