class Station(db.Model):
"""A Nice Ride station
Attributes
----------
station_id : Integer
Unique station identifier
name : String
Name of the station
docks : Integer
Number of docks at the station (max number of bikes)
latitude : Float
Latitude of the station's location
longitude : Float
Longitude of the station's location
"""
station_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256), index=True, unique=False)
docks = db.Column(db.Integer, index=True, unique=False)
latitude = db.Column(db.Float(), index=True, unique=False)
longitude = db.Column(db.Float(), index=True, unique=False)
def __repr__(self):
return '<Station %r>' % self.name
class Purdetails(db.Model):
autoid = db.Column(db.Integer(), primary_key=True)
pid = db.Column(db.String(9))
medid = db.Column(db.String(4))
medname = db.Column(db.String(40))
qtypur = db.Column(db.Integer())
rate = db.Column(db.Float())
amt = db.Column(db.Float())
class Rentals(db.Model):
__tablename__ = 'rentals'
rental_ID = db.Column(db.Integer, primary_key=True)
car_ID = db.Column(db.Integer, db.ForeignKey('cars.car_ID'))
rental_start = db.Column(db.Date, nullable=False)
rental_end = db.Column(db.Date, nullable=False)
insurance_type = db.Column(db.String(20))
excess = db.Column(db.Float(7))
price = db.Column(db.Float(7), nullable=False)
def __repr__(self):
return ''.join(['Rental ', str(self.rental_ID)])
class Productos(db.Model):
#Tell SQLAlchemy what the table name is and if there's any table-specific arguments it should know about
__tablename__ = 'productos'
#tell SQLAlchemy the name of column and its attributes:
product_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
units = db.Column(db.String(80))
product_title = db.Column(db.String(80))
location_origin = db.Column(db.String(80))
unit_price = db.Column(db.Float(8))
amount = db.Column(db.Float(8))
current_price = db.Column(db.Float(8))
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
week = db.Column(db.Integer, default=date.today().isocalendar()[1])
year = db.Column(db.Integer, default=date.today().year)
agricultor_id = db.Column(db.Integer, db.ForeignKey('agricultor.id'))
agricultor = db.relationship(Agricultor)
# pedido_join = db.relationship("Pedido")
def __init__(self, product_id, units, product_title, location_origin,
unit_price, amount, current_price, created_date, week, year,
agricultor_id, agricultor):
self.product_id = product_id
self.units = units
self.product_title = product_title
self.location_origin = location_origin
self.unit_price = unit_price
self.amount = amount
self.current_price = current_price
self.created_date = created_date
self.week = week
self.year = year
self.agricultor_id = agricultor_id
self.agricultor = agricultor
def __repr__(self):
return '<Nombre %r>' % self.product_title
@property
def serialize(self):
return {
'product_title': self.product_title,
'units': self.units,
'product_id': self.product_id,
'unit_price': self.unit_price,
'week': self.week,
'agricultor_id': self.agricultor_id,
}
class Chromatographic_Condition(db.Model, UserMixin):
__tablename__ = 'chromatographic_condition'
id = db.Column('Acqui_Chrom_ID',
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
column_id = db.Column('Column_ID', db.Integer, unique=True, nullable=False)
sample_injection_volume = db.Column('Sample_Injection_Volume',
db.String(255),
nullable=False)
mobile_phase_a = db.Column('Mobile_Phase_A', db.Float(10), nullable=False)
mobile_phase_b = db.Column('Mobile_Phase_B', db.Float(10), nullable=False)
def __repr__(self):
return f"Post('{self.id}', '{self.sample_injection_volume}')"
class Book(db.Model):
__tablename__ = 'book'
name = db.Column(db.String(20), nullable=False)
ISBN = db.Column(db.String(32), primary_key=True)
press = db.Column(db.String(20), nullable=False)
author = db.Column(db.String(10), nullable=False)
price = db.Column(db.Float(10), nullable=False)
updated_time = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
created_time = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
def to_json(self):
return {
'name': self.name,
'ISBN': self.ISBN,
'press': self.press,
'author': self.author,
'price': self.price,
'updated_time': self.updated_time,
'created_time': self.created_time,
}
class Observation(db.Model):
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(300))
date = db.Column(db.Date)
ncoordinates = db.Column(db.Float())
ecoordinates = db.Column(db.Float())
account_id = db.Column(db.Integer,
db.ForeignKey('account.id', ondelete='CASCADE'),
nullable=False)
species_id = db.Column(db.Integer,
db.ForeignKey('species.id', ondelete='CASCADE'),
nullable=False)
def __init__(self, description):
self.description = description
class BookReview(db.Model):
__tablename__ = "book_review"
id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer(), db.ForeignKey("book.id"))
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
rating = db.Column(db.Float(), nullable=True)
review = db.Column(db.Text(), nullable=True)
class Question(db.Model):
"""deployment model"""
__tablename__ = 'questions'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
question = db.Column(db.String())
function_name = db.Column(db.String())
session = db.Column(db.Integer())
args = db.Column(db.PickleType())
answer = db.Column(db.PickleType())
timeout = db.Column(db.Float())
created_date = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
def __init__(self, name, question, function_name, args, answer, timeout,
session):
self.name = name
self.question = question
self.function_name = function_name
self.answer = answer
self.session = session
self.args = args
self.timeout = timeout
def __repr__(self):
return '<question {0}, {1}>'.format(self.name, self.id)
class Product(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(150), nullable=False)
price = db.Column(db.Float(10), nullable=False)
class Acquisition_Hrms(db.Model, UserMixin):
__tablename__ = 'acquisition_hrms'
id = db.Column('Acqui_Hrms_ID',
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
hrms_mode = db.Column('Hrms_Mode', db.String(255), nullable=False)
hrms_source_gas1 = db.Column('Hrms_Source_Gas1',
db.Float(10),
nullable=False)
hrms_source_gas2 = db.Column('Hrms_Source_Gas2',
db.Float(10),
nullable=False)
hrms_curtain_gas = db.Column('Hrms_Curtain_Gas',
db.Float(10),
nullable=False)
hrms_ionisation = db.Column('Hrms_Ionisation',
db.Float(10),
nullable=False)
hrms_voltage = db.Column('Hrms_Voltage', db.Float(10), nullable=False)
hrms_polarity = db.Column('Hrms_Polarity', db.Float(10), nullable=False)
hrms_source = db.Column('Hrms_Source', db.Float(10), nullable=False)
def __repr__(self):
return f"Post('{self.id}', '{self.system_brand}')"
class Location(db.Model):
"""Model for Location data"""
# Fields
id = db.Column(db.Integer, primary_key=True)
ip = db.Column(db.String(15))
latitude = db.Column(db.Numeric(8, 6))
longitude = db.Column(db.Numeric(9, 6))
positionAccuracy = db.Column(db.Float())
altitude = db.Column(db.Float())
altitudeAccuracy = db.Column(db.Float())
speed = db.Column(db.Float())
heading = db.Column(db.Float())
w3w = db.Column(db.String(60))
timeStamp = db.Column(db.DateTime(), index=True)
# Relationships
track_id = db.Column(db.Integer, db.ForeignKey('track.id'))
class Market(db.Model):
id = db.Column(db.Integer, primary_key=True)
game = db.Column(db.Integer, db.ForeignKey('games.id'), nullable=False)
seller = db.Column(db.String(30), nullable=False)
description = db.Column(db.String(500), nullable=True)
price = db.Column(db.Float(7, 2), nullable=False)
def __repr__(self):
return ''.join(
['ID : ', str(self.id), '\r\n', 'Game : ',
str(self.game)])
class Walls(db.Model):
id = db.Column(db.Integer, primary_key=True)
location_id = db.Column(db.Integer,
db.ForeignKey('locations.id'),
nullable=False)
activity_id = db.Column(db.Integer,
db.ForeignKey('activities.id'),
nullable=False)
nickname = db.Column(db.String(30), unique=True)
wall_size = db.Column(db.String(30), unique=True)
rating = db.Column(db.Float(5), nullable=True)
class Sample_Location(db.Model, UserMixin):
__tablename__ = 'sample_location'
id = db.Column('Location_ID',
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
sample_id = db.Column('Sample_ID', db.Integer, unique=True, nullable=False)
location_longitude = db.Column('Location_Longitude',
db.Float(10),
nullable=False)
location_altitude = db.Column('Location_Altitude',
db.Float(10),
nullable=False)
location_latitude = db.Column('Location_Latitude',
db.Float(10),
nullable=False)
location_datum = db.Column('Location_Datum', db.Float(10), nullable=False)
def __repr__(self):
return f"Post('{self.id}', '{self.location_longitude}', '{self.location_altitude}', '{self.location_latitude}')"
class Agricultor(db.Model):
__tablename__ = 'agricultor'
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
categoria = db.Column(db.String(30))
contacto_id = db.Column(db.Integer, db.ForeignKey('contacto.id'))
contacto = db.relationship(Contacto)
pedido_minimo = (db.Float(5, 2))
def __repr__(self):
return '<Agricultor %r>' % self.name
class SavingsTotal(db.Model):
""" Total savings model """
__tablename__ = 'total_savings_log'
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4)
total = db.Column(db.Float(precision=2), nullable=False)
created = db.Column(db.TIMESTAMP, default=datetime.now())
savings_id = db.Column(UUID, db.ForeignKey('savings_entries.id'))
user_id = db.Column(UUID, db.ForeignKey('users.id'))
def __repr__(self):
return f'<SavingsTotal total={self.total} savings_id={self.savings_id}>'
class Bid(db.Model):
__tablename__ = 'bids'
id = db.Column(db.Integer, primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey('items.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
amount = db.Column(db.Float())
winner = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.BigInteger())
bid_detail = db.relationship("BidDetail", uselist=False, backref="bids")
def __repr__(self):
return '<id {}>'.format(self.id)
class SavingsGoal(db.Model):
""" Savings Goal Model """
__tablename__ = 'savings_goals'
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4)
start_date = db.Column(db.Date, default=date.today(), nullable=False)
end_date = db.Column(db.Date, default=date.today(), nullable=False)
amount = db.Column(db.Float(precision=2), nullable=False)
created = db.Column(db.TIMESTAMP, default=datetime.now())
user_id = db.Column(UUID, db.ForeignKey('users.id'))
def __repr__(self):
return f'<SavingsGoal amount={self.amount} user={self.user_id}>'
class Chrom_Time(db.Model, UserMixin):
__tablename__ = 'chrom_time'
id = db.Column('Chrom_Events_ID',
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
acqui_chrom_id = db.Column('Acqui_Chrom_ID',
db.Integer,
unique=True,
nullable=False)
event_stage = db.Column('Event_Stage', db.String(255), nullable=False)
flow_rate = db.Column('Flow_Rate', db.Float(10), nullable=False)
time = db.Column('Time',
db.DateTime,
nullable=False,
default=datetime.utcnow)
gradient_a_or_b = db.Column('Gradient_A/B', db.Float(10), nullable=False)
a_or_b = db.Column('A/B', db.String(2), nullable=False)
oven_temp = db.Column('Oven_Temp', db.Float(10), nullable=False)
def __repr__(self):
return f"Post('{self.id}', '{self.event_stage}')"
class Assignment(db.Model):
id = db.Column(db.Integer, primary_key=True)
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
project = db.relationship(Project, backref='assignments')
user = db.relationship(User, backref='assignments')
rate = db.Column(db.Float(), nullable=False)
currency = db.Column(db.String(10), nullable=False)
rate_basis = db.Column(db.String(10), nullable=False)
def __repr__(self):
return '<Assignment -ID - {}>'.format(self.id)
class DonationModel(db.Model):
__tablename__ = 'donations'
id = db.Column(db.Integer, primary_key=True)
frequency = db.Column(frequencies_enum)
amount = db.Column(db.Float(precision=2))
created_on = db.Column(db.DateTime, default=db.func.now())
updated_on = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
lead_id = db.Column(db.Integer, db.ForeignKey('leads.id'))
lead = db.relationship('LeadModel')
operator_id = db.Column(db.Integer, db.ForeignKey('operators.id'))
operator = db.relationship('OperatorModel')
def __init__(self, frequency, amount, lead_id, operator_id):
self.frequency = frequency
self.amount = amount
self.lead_id = lead_id
self.operator_id = operator_id
@classmethod
def find_by_id(cls, _id):
donation = cls.query.filter_by(id=_id).first()
return donation
@classmethod
def find_by_lead_id(cls, lead_id):
donation = cls.query.filter_by(lead_id=lead_id).first()
return donation
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def json(self):
return {
'id': self.id,
'frequency': self.frequency,
'amount': self.amount,
'lead_id': self.lead_id,
'operator_id': self.operator_id
}
class Bill(db.Model):
""" Bill Model """
__tablename__ = 'bills'
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4)
bill_name = db.Column(db.String, nullable=False)
bill_due_date = db.Column(db.Date, default=date.today())
bill_amount = db.Column(db.Float(precision=2), nullable=False)
is_paid = db.Column(db.Text, default='Not Paid')
created = db.Column(db.TIMESTAMP, default=datetime.now())
user_id = db.Column(UUID, db.ForeignKey('users.id'))
def __repr__(self):
return f'<Bill name={self.bill_name} amount={self.bill_amount} user={self.user_id}>'
class Offer(db.Model):
"""
Defines table in which information on job offers
is stored
"""
id = db.Column(db.Integer, primary_key=True)
job_title = db.Column(db.String(120), index=True)
pay_offer = db.Column(db.Float(asdecimal=True), index=True)
contact_email = db.Column(db.String(120), index=True)
job_description = db.Column(db.String(500))
date = db.Column(db.String(25))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
company_id = db.Column(db.Integer, db.ForeignKey('company.id'))
def __repr__(self):
return '<Position: {}, Pay: {}'.format(self.job_title, self.pay_offer)
class SavingsEntry(db.Model):
""" Model for Savings Entries """
__tablename__ = 'savings_entries'
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4)
savings_date = db.Column(db.Date, default=date.today(), nullable=False)
transaction_type = db.Column(db.String, nullable=False)
amount = db.Column(db.Float(precision=2))
created = db.Column(db.TIMESTAMP, default=datetime.now())
user_id = db.Column(UUID, db.ForeignKey('users.id'))
total_savings = db.relationship('SavingsTotal',
backref='savings_entries',
cascade='all, delete, delete-orphan')
def __repr__(self):
return f'<SavingsEntry transaction={self.transaction_type} amount={self.amount} user={self.user_id}>'
class Product(Base):
name = db.Column(db.String(144), nullable=False)
price = db.Column(db.Float(2), nullable=False)
description = db.Column(db.String(144), nullable=False)
account_id = db.Column(db.Integer,
db.ForeignKey('account.id'),
nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
Order = db.relationship("Order", uselist=False, backref="Product")
def __init__(self, name, price, description):
self.name = name
self.price = price
self.description = description
class User(db.Model):
"""This class represents the users table."""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255))
rating = db.Column(db.Float(precision=1))
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime,
default=db.func.current_timestamp(),
nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
def __init__(self,
first_name,
email,
password,
last_name=None,
admin=False):
self.email = email
self.password = app_bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')).decode()
self.admin = admin
self.first_name = first_name
self.last_name = last_name
self.rating = None
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_all():
return User.query.all()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return "<Users: {}>".format(self.email)
class Book(db.Model):
__tablename__ = 'Book_Information'
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String(64), index=True, nullable=False)
topic = db.Column(db.String(64), index=True, nullable=False)
name = db.Column(db.String(64), index=True, nullable=False)
summary = db.Column(db.String(1000), index=True, nullable=False)
image = db.Column(db.String(1000), index=True, nullable=False)
# users = db.Column(db.String(20), db.ForeignKey('User_Information.name'), index=True, nullable=True)
price = db.Column(db.Float(3), index=True, nullable=False)
def __init__(self, name, author, summary, price, topic, image):
self.name = name
self.author = author
self.summary = summary
self.price = price
self.topic = topic
self.image = image
class Pedido(db.Model):
__tablename__ = 'pedido'
id = db.Column(db.Integer, primary_key=True)
quantity = db.Column(db.String(30))
week = db.Column(db.Integer)
product_name = db.Column(db.String(80))
product_price = db.Column(db.Float(8))
product_units = db.Column(db.String(80))
user_name = db.Column(db.String(30))
email = db.Column(db.String(50))
# user_email_join = db.relationship(User, foreign_keys=[email])
# user_join = db.relationship(User, foreign_keys=[user_name])
# product_price_join = db.relationship(Productos, foreign_keys=[product_price])
# product_unit_join = db.relationship(Productos, foreign_keys=[product_units])
# product_join = db.relationship(Productos, foreign_keys=[product_name])
year = db.Column(db.Integer, default=date.today().year)
week = db.Column(db.Integer, default=date.today().isocalendar()[1])
is_confirmed = db.Column(db.Boolean, default=False)
class CallModel(db.Model):
__tablename__ = 'calls'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String(20))
time = db.Column(db.String(20))
duration = db.Column(db.Float(precision=2))
lead_id = db.Column(db.Integer, db.ForeignKey('leads.id'))
lead = db.relationship('LeadModel')
operator_id = db.Column(db.Integer, db.ForeignKey('operators.id'))
operator = db.relationship('OperatorModel')
def __init__(self, date, time, duration, lead_id, operator_id):
self.date = datetime.strptime(date, '%m-%d-%Y').date()
self.time = datetime.strptime(time, '%H::%M::%S').time()
self.duration = duration
self.lead_id = lead_id
self.operator_id = operator_id
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def json(self):
return {
'id': self.id,
'date': self.date,
'time': self.time,
'duration': self.duration,
'operator_id': self.operator_id,
'lead_id': self.lead_id
}
