class Staff(db.Model):
__tablename__ = 'staff'
staff_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
primary_key=True)
name = db.Column(db.String(60), nullable=False)
last_name = db.Column(db.String(60), nullable=False)
salary = db.Column(db.Float, default=db.Float(2200.5))
phone_number = db.Column(db.Integer)
address = db.Column(db.String(100))
start_at = db.Column(db.DateTime)
finish_at = db.Column(db.DateTime)
assistant_t = db.relationship('Assistant',
back_populates='staff_t',
foreign_keys='Assistant.staff_id')
vet_t = db.relationship('Vet',
back_populates='staff_t',
foreign_keys='Vet.staff_id')
secretary_t = db.relationship('Secretary',
back_populates='staff_t',
foreign_keys='Secretary.staff_id')
cleaner_t = db.relationship('Cleaner',
back_populates='staff_t',
foreign_keys='Cleaner.staff_id')
__mapper_args__ = {"polymorphic_identity": "staff"}
class Pet(db.Model):
__tablename__ = 'pet'
pet_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), default='Çomar')
''' Attributes inherited from Stays relation'''
checkin_date = db.Column(db.DateTime, default=datetime.utcnow)
checkout_date = db.Column(db.DateTime)
species = db.Column(db.String(60))
race = db.Column(db.String(60))
weight = db.Column(db.Float, nullable=False)
age = db.Column(db.Integer, nullable=False)
owner_ssn = db.Column(db.Integer, db.ForeignKey('owner.ssn'))
treatments = db.relationship('Treatment', backref='pet')
# Stays relation
cage = db.relationship('Cage', secondary=Stay, back_populates='pet')
# multivalued disabilities
disabilities = db.relationship('Disability')
def to_dict(self):
return {
"Id": self.pet_id,
"Age": self.age,
"Name": self.name,
"Owner": [
self.owner_ssn if self.owner is not None else "Bizim Yurdumuz\
Sokaklar"],
"Weight": self.weight,
"Species": self.species,
"Race": self.race,
}
class Assistant(User):
__tablename__ = 'assistant'
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
primary_key=True)
field = db.Column(db.String(60), nullable=False)
end_date = db.Column(db.DateTime)
staff_id = db.Column(db.Integer, db.ForeignKey('staff.staff_id'))
staff_t = db.relationship('Staff',
back_populates='assistant_t',
foreign_keys=[staff_id])
# end_date = db.Column(db.DateTime)
supervisor_id = db.Column(db.Integer, db.ForeignKey('vet.id'))
supervisor = db.relationship('Vet',
back_populates='supervisee',
foreign_keys=[supervisor_id])
def user_dashboard(self):
return render_template("assistant_dashboard.html", user=self)
__mapper_args__ = {
"polymorphic_identity": "assistant",
}
@classmethod
def create_user(cls, username, password):
hashed_pw = bc.generate_password_hash(password).decode('utf-8')
new_user = cls(username=username, password=hashed_pw)
db.session.add(new_user)
db.session.commit()
class Cage(db.Model):
__tablename__ = 'cages'
cage_id = db.Column(db.Integer, nullable=False, primary_key=True)
size = db.Column(db.Integer, nullable=False)
capacity = db.Column(db.Integer, nullable=False)
emptiness = db.Column(db.Boolean, nullable=False, default=True)
# multivalued suitability attribute
suitabilities = db.relationship('Suitability', backref='cage')
# multivalued notes attribute
notes = db.relationship('CageNotes', backref='cage')
# Stays relation
pet = db.relationship('Pet', secondary=Stay, back_populates='cage')
class Owner(db.Model):
__tablename__ = 'owner'
ssn = db.Column(db.Integer, primary_key=True, autoincrement=False)
name = db.Column(db.String(100), nullable=False)
last_name = db.Column(db.String(100), nullable=False)
sex = db.Column(db.String(5), nullable=False)
phone = db.Column(db.Integer, nullable=False, unique=True)
email = db.Column(db.String(60))
address = db.Column(db.String(60))
# Owner makes Appointment (Weak entity)
appointments = db.relationship('Appointment', backref='customer')
# Owner pays Invoices
invs = db.relationship('Invoices', backref='customer')
# Owner owns Pet
pets = db.relationship('Pet', backref='owner')
def __repr__(self):
return "id:{} name:{} sex:{} email:{} phone:{}".format(
self.ssn, self.name, self.sex, self.email, self.phone)
@classmethod
def create_owner(
cls,
ssn,
owner_name,
last_name,
owner_sex,
owner_email,
owner_address,
owner_phone):
new_owner = cls(
ssn=ssn,
name=owner_name,
last_name=last_name,
sex=owner_sex,
email=owner_email,
address=owner_address,
phone=owner_phone)
db.session.add(new_owner)
db.session.commit()
return new_owner
def to_dict(self):
return {
"id": self.ssn,
"tc": self.ssn,
"name": self.name,
"last_name": self.last_name,
"phone": self.phone
}
class InvoicesServiceLink(db.Model):
__tablename__ = 'invoices_service_link'
invoices_serial_number = db.Column(
db.Integer,
db.ForeignKey('invoices.serial_number'),
primary_key=True,
autoincrement=False)
service_name = db.Column(
db.Integer,
db.ForeignKey('service.name'),
primary_key=True,
autoincrement=False)
invoices = db.relationship(Invoices, backref=db.backref('invoices_assoc'))
service = db.relationship(Service, backref=db.backref('service_assoc'))
class Cleaner(User):
__tablename__ = 'cleaner'
id = db.Column(db.Integer, db.ForeignKey('user.user_id'), primary_key=True)
cleaning_company = db.Column(db.String,
default='Caglayan pislik temizleyiciler',
nullable=False)
staff_id = db.Column(db.Integer, db.ForeignKey('staff.staff_id'))
staff_t = db.relationship('Staff',
back_populates='cleaner_t',
foreign_keys=[staff_id])
def __repr__(self):
return 'email: {} admin: {}'.format(self.email, self.is_admin)
@classmethod
def create_user(cls, username, password, cleaning_company):
cleaner = super().create_user(username=username, password=password)
cleaner.cleaning_company = cleaning_company
def user_dashboard(self):
return render_template("cleaner_dashboard.html", user=self)
__mapper_args__ = {
"polymorphic_identity": "cleaner",
}
class Service(db.Model):
__tablename__ = 'service'
name = db.Column(
db.String,
primary_key=True,
nullable=False,
autoincrement=False)
cost = db.Column(db.Float, nullable=False)
serial_number = db.Column(db.Integer,
db.ForeignKey('invoices.serial_number'))
invoices = db.relationship('Invoices', secondary='invoices_service_link')
class Invoices(db.Model):
__tablename__ = 'invoices'
serial_number = db.Column(
db.Integer,
primary_key=True,
autoincrement=False)
quantity = db.Column(db.Integer, nullable=False)
transaction_date = db.Column(db.DateTime, nullable=False)
cost = db.Column(db.Float, nullable=False)
service_quantity = db.Column(db.Integer, nullable=False)
owner_ssn = db.Column(db.Integer, db.ForeignKey('owner.ssn'))
# Invoice has service
services = db.relationship('Service', secondary='invoices_service_link')
class Vet(User):
__tablename__ = 'vet'
id = db.Column(db.Integer, db.ForeignKey('user.user_id'), primary_key=True)
field = db.Column(db.String, default='Genel uzman', nullable=False)
staff_id = db.Column(db.Integer, db.ForeignKey('staff.staff_id'))
staff_t = db.relationship('Staff',
back_populates='vet_t',
foreign_keys=[staff_id])
supervisee = db.relationship('Assistant',
foreign_keys='Assistant.supervisor_id',
back_populates='supervisor')
appos = db.relationship('Appointment',
back_populates='assigned',
foreign_keys='Appointment.vet_id')
def __repr__(self):
return "{} FIELD: {}".format(super().__repr__(), self.field)
def to_dict(self):
return super().to_dict().update({
'field': self.field,
'end_date': self.end_date.__str__(),
'supervisees': self.supervisee
})
__mapper_args__ = {
"polymorphic_identity": "vet",
}
def user_dashboard(self):
return render_template("vet_dashboard.html", user=self)
@classmethod
def create_user(cls, username, password, field=None):
hashed_pw = bc.generate_password_hash(password).decode('utf-8')
new_user = cls(username=username, password=hashed_pw, field=field)
db.session.add(new_user)
db.session.commit()
class Treatment(db.Model):
_tablename_ = 'treatment'
record_id = db.Column(db.Integer, primary_key=True)
record_type = db.Column(db.String(250))
start_date = db.Column(db.DateTime)
end_date = db.Column(db.DateTime)
pet_id = db.Column(db.Integer, db.ForeignKey('pet.pet_id'))
medicines = db.relationship('Medicine', backref='medicines')
def to_dict(self):
return {
'Id': self.record_id,
'Record_type': self.record_type,
'Start_date': self.start_date.__str__(),
'End_date': self.end_date.__str__(),
}
class Appointment(db.Model):
__tablename__ = 'appointment'
appo_id = db.Column(db.Integer, primary_key=True)
on = db.Column(db.DateTime, nullable=False)
appo_type = db.Column(db.String, nullable=False)
owner_ssn = db.Column(
db.Integer,
db.ForeignKey('owner.ssn'),
primary_key=True,
autoincrement=False)
vet_id = db.Column(db.Integer, db.ForeignKey('vet.id'))
assigned = db.relationship(
'Vet',
back_populates='appos',
foreign_keys=[vet_id])
class Secretary(User):
__tablename__ = 'secretary'
id = db.Column(db.Integer, db.ForeignKey('user.user_id'), primary_key=True)
staff_id = db.Column(db.Integer, db.ForeignKey('staff.staff_id'))
staff_t = db.relationship('Staff',
back_populates='secretary_t',
foreign_keys=[staff_id])
# languages = db.relationship('Languages', backref='languages')
@classmethod
def create_user(cls, username, password):
super().create_user(username=username, password=password)
def user_dashboard(self):
return render_template("secretary_dashboard.html", user=self)
__mapper_args__ = {
"polymorphic_identity": "secretary",
}
