class Address(db.Model):
REQUIRED_PARAMETERS = {
'country_name', 'street_address', 'city_name', 'zip_code'
}
__tablename__ = 'address'
address_id = db.Column(db.Integer, primary_key=True)
country_name = db.Column(db.String(55), nullable=False)
region_name = db.Column(db.String(55), nullable=True)
street_address = db.Column(db.String(95), nullable=False)
city_name = db.Column(db.String(28), nullable=False)
zip_code = db.Column(db.String(6), nullable=False)
user = db.relationship("User")
def __init__(self, **args):
self.country_name = args.get('country_name')
self.region_name = args.get('region_name')
self.street_address = args.get('street_address')
self.city_name = args.get('city_name')
self.zip_code = args.get('zip_code')
@property
def pk(self):
return self.address_id
@staticmethod
def getAllAddresses():
return Address().query.all()
@staticmethod
def getAddressesByCountry(cname):
return Address().query.filter_by(country_name=cname).all()
@staticmethod
def getAddressesByRegion(rname):
return Address().query.filter_by(region_name=rname).all()
@staticmethod
def getStreetAddresses(saddress):
return Address().query.filter_by(street_address=saddress).all()
@staticmethod
def getAddressById(aid):
return Address().query.filter_by(address_id=aid).first()
@staticmethod
def getSpecificAddress(json):
return Address().query.filter_by(country_name=json['country_name'],
region_name=json['region_name'],
street_address=json['street_address'],
city_name=json['city_name'],
zip_code=json['zip_code']).first()
def create(self):
db.session.add(self)
db.session.commit()
return self
class MedicalOffice(db.Model):
__tablename__ = 'medical_office'
office_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
unique=True)
owner_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('user.user_id'),
nullable=False)
office_name = db.Column(db.String(50), nullable=False)
location_id = db.Column(db.Integer,
db.ForeignKey('location.location_id'),
nullable=True)
office_phone_number = db.Column(db.String(15), nullable=False)
def __init__(self, **args):
self.office_id = args.get('office_id')
self.owner_id = args.get('owner_id')
self.office_name = args.get('office_name')
self.location_id = args.get('location_id')
self.office_phone_number = args.get('office_phone_number')
@staticmethod
def getAllMedicalOffices():
return MedicalOffice().query.all()
@staticmethod
def getMedicalOfficesbyOwnerId(oid):
return MedicalOffice().query.filter_by(owner_id=oid).all()
@staticmethod
def getMedicalOfficeById(oid):
return MedicalOffice().query.filter_by(office_id=oid).first()
@staticmethod
def getMedicalOfficeByAddressId(aid):
return MedicalOffice().query.filter_by(address_id=aid).first()
def create(self):
db.session.add(self)
db.session.commit()
return self
class Users(db.Model):
__tablename__ = 'users'
user_id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(150), nullable=False)
password = db.Column(db.String(150), nullable=False)
username = db.Column(db.String(50), nullable=False, unique=True)
role = db.Column(db.String(10), nullable=False)
business = db.relationship("Businesses")
appointment = db.relationship("Appointment")
def __init__(self, **args):
self.first_name = args.get('first_name')
self.last_name = args.get('last_name')
self.email = args.get('email')
self.password = args.get('password')
self.username = args.get('username')
self.role = args.get('role')
@property
def primaryKey(self):
return self.user_id
@staticmethod
def getUsers():
return Users().query.all()
@staticmethod
def getUserById(uid):
return Users().query.filter_by(user_id=uid).first()
@staticmethod
def getUserByEmail(uemail):
return Users().query.filter_by(email=uemail).first()
@staticmethod
def getUserByUsername(uname):
return Users().query.filter_by(username=uname).first()
@staticmethod
def getOwners():
return Users().query.filter_by(role='owner').all()
@staticmethod
def getCustomers():
return Users().query.filter_by(role='customer').all()
def create(self):
db.session.add(self)
db.session.commit()
return self
@staticmethod
def updateRole(uid):
user = Users.getUserById(uid)
user.role = 'owner'
db.session.commit()
return user
class Services(db.Model):
__tablename__ = 'services'
service_id = db.Column(db.Integer, primary_key=True)
service_name = db.Column(db.String(50), nullable=False)
business = db.relationship("Businesses")
def __init__(self, **args):
self.service_name = args.get('service_name')
def __repr__(self):
return self.service_name
@property
def primaryKey(self):
return self.service_id
@staticmethod
def getServices():
return Services().query.all()
@staticmethod
def getServiceById(sid):
return Services().query.filter_by(service_id=sid).first()
class Appointment(db.Model):
__tablename__ = 'appointment'
appt_id = db.Column(db.Integer, primary_key=True)
start_time = db.Column(db.String(50), nullable=False)
end_time = db.Column(db.String(50), nullable=False)
confirmation_number = db.Column(db.Integer, nullable=True)
business_id = db.Column(db.Integer, db.ForeignKey('businesses.business_id'), nullable=False)
business_name = db.Column(db.String(50), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'), nullable=True)
number_of_customers = db.Column(db.Integer, nullable=True)
def __init__(self, **args):
self.start_time = args.get('start_time')
self.end_time = args.get('end_time')
self.confirmation_number = args.get('confirmation_number')
self.business_id = args.get('business_id')
self.business_name = args.get('business_name')
self.user_id = args.get('user_id')
self.number_of_customers = args.get('number_of_customers')
@property
def primaryKey(self):
return self.appt_id
@staticmethod
def getAppointments():
return Appointment().query.all()
@staticmethod
def getApptById(aid):
return Appointment().query.filter_by(appt_id=aid).first()
@staticmethod
def getApptByUser(uid):
return Appointment().query.filter_by(user_id=uid).all()
@staticmethod
def getApptByBusiness(bid):
return Appointment().query.filter_by(business_id=bid).all()
@staticmethod
def getApptByStartTime(dt):
return Appointment().query.filter_by(start_time=dt).all()
def create(self):
db.session.add(self)
db.session.commit()
return self
@staticmethod
def updateAppt(aid, uid):
appt = Appointment.getApptById(aid)
appt.user_id = uid
appt.confirmation_number = randint(0,1000)
db.session.commit()
return appt
@staticmethod
def cancelAppt(aid):
appt = Appointment.getApptById(aid)
appt.user_id = None
appt.confirmation_number = None
db.session.commit()
return appt
class Businesses(db.Model):
__tablename__ = 'businesses'
business_id = db.Column(db.Integer, primary_key=True)
business_name = db.Column(db.String(100), nullable=False)
address = db.Column(db.String(150), nullable=False)
city = db.Column(db.String(50), nullable=False)
zip_code = db.Column(db.String(5), nullable=False)
business_email = db.Column(db.String(150), nullable=False)
business_phone = db.Column(db.String(12), nullable=False)
max_capacity = db.Column(db.Integer, nullable=False)
owner_id = db.Column(db.Integer, db.ForeignKey('users.user_id'), nullable=False)
service_id = db.Column(db.Integer, db.ForeignKey('services.service_id'), nullable=True)
appointment = db.relationship("Appointment")
def __init__(self, **args):
self.business_name = args.get('business_name')
self.business_email = args.get('business_email')
self.business_phone = args.get('business_phone')
self.address = args.get('address')
self.city = args.get('city')
self.zip_code = args.get('zip_code')
self.max_capacity = args.get('max_capacity')
self.owner_id = args.get('owner_id')
self.service_id = args.get('service_id')
@property
def primaryKey(self):
return self.business_id
@staticmethod
def getBusinesses():
return Businesses().query.all()
@staticmethod
def getBusinessById(bid):
return Businesses().query.filter_by(business_id=bid).first()
@staticmethod
def getAllBusinessesByCity(ct):
return Businesses().query.filter_by(city=ct).all()
@staticmethod
def getAllBusinessesByZipCode(zc):
return Businesses().query.filter_by(zip_code=zc).all()
@staticmethod
def getAllBusinessesByMaxCapacity(mc):
return db.session.query(Businesses).filter(Businesses.max_capacity>=mc)
@staticmethod
def getBusinessesByService(sid):
return Businesses().query.filter_by(service_id=sid).all()
@staticmethod
def getBusinessByOwner(uid):
return Businesses().query.filter_by(owner_id=uid).first()
def create(self):
db.session.add(self)
db.session.commit()
return self
class User(db.Model):
REQUIRED_PARAMETERS = {
'gender_id', 'address_id', 'full_name', 'birthdate', 'phone_number',
'email', 'password', 'active'
}
__tablename__ = 'user'
user_id = db.Column(UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
gender_id = db.Column(
db.Integer,
nullable=False) #0 is male, 1 is female and 2 is non binary
address_id = db.Column(db.Integer,
db.ForeignKey('address.address_id'),
nullable=False)
full_name = db.Column(db.String(41), nullable=False)
birthdate = db.Column(db.Date, nullable=False)
phone_number = db.Column(db.String(13), nullable=False)
email = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean, nullable=False, default=False)
patient = db.relationship("Patient", foreign_keys='Patient.user_id')
doctor = db.relationship("Doctor", foreign_keys='Doctor.user_id')
def __init__(self, **args):
self.full_name = args.get('full_name')
self.birthdate = args.get('birthdate')
self.phone_number = args.get('phone_number')
self.email = args.get('email')
self.password = args.get('password')
self.gender_id = args.get('gender_id')
self.address_id = args.get('address_id')
self.active = args.get("active")
def get_user_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'email': self.email}).decode('utf-8')
@staticmethod
def verify_user_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
email = s.loads(token)['email']
except:
return None
return email
@property
def pk(self):
return self.user_id
@staticmethod
def getAllUsers():
return User().query.all()
@staticmethod
def getUsersByAddressId(aid):
return User().query.filter_by(address_id=aid).all()
@staticmethod
def getUsersByGender(gid):
return User().query.filter_by(gender_id=gid).all()
@staticmethod
def getUserById(uid):
return User().query.filter_by(user_id=uid).first()
@staticmethod
def getUserByEmail(uemail):
return User().query.filter_by(email=uemail).first()
@staticmethod
def updateUserInfo(**args):
user = User.getUserById(args.get('user_id'))
user.phone_number = args.get('phone_number')
user.email = args.get('email')
user.password = args.get('password')
user.address_id = args.get('address_id')
db.session.commit()
return user
def activateUser(self):
self.active = True
db.session.commit()
return self
def create(self):
db.session.add(self)
db.session.commit()
return self