class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
payment_method = db.Column(db.String(10))
shipping_method = db.Column(db.String(10))
date_placed = db.Column(db.Date())
date_delivered = db.Column(db.Date())
price = db.Column(db.Float)
account_id = db.Column(db.String(100), db.ForeignKey('account.email'))
account = db.relationship('Account',
backref=db.backref('orders', lazy='dynamic'))
def __init__(self,
payment_method,
shipping_method,
account,
date_placed=None,
date_delivered=None):
self.payment_method = payment_method
self.shipping_method = shipping_method
self.date_placed = datetime.now()
self.date_delivered = self.date_placed + timedelta(days=10)
self.account = account
def __repr__(self):
return '<Order %r>' % self.account_id
class Shift(db.Model):
__tablename__ = "shifts"
day = db.Column(db.Date(), primary_key=True)
staff_id = db.Column(db.String(), primary_key=True)
start_time = db.Column(db.Time(), nullable=False)
end_time= db.Column(db.Time(), nullable=False)
def get_monthly_shift(target_month, end_target):
monthly_shift = Shift.query.join(Staff, Shift.staff_id==Staff.staff_id) \
.add_columns(Shift.day, Staff.nickname, Shift.start_time, Shift.end_time) \
.filter(Shift.day.between(target_month, end_target)).order_by(Shift.start_time).all()
return monthly_shift
def get_daily_shift(target_date):
daily_shift = Shift.query.join(Staff, Shift.staff_id==Staff.staff_id) \
.add_columns(Shift.day, Staff.staff_id, Staff.nickname, Shift.start_time, Shift.end_time) \
.filter(Shift.day==target_date).order_by(Shift.start_time, Staff.staff_id).all()
return daily_shift
def add_shift(target_date, staff_id, start_time, end_time):
shift = Shift(day=target_date, staff_id=staff_id, start_time=start_time, end_time=end_time)
db.session.add(shift)
db.session.commit()
def del_shift(target_date, staff_id):
db.session.query(Shift).filter(Shift.day==target_date, Shift.staff_id==staff_id).delete()
db.session.commit()
class NonDate(db.Model):
__tablename__="nondates"
id = db.Column(db.Integer, primary_key=True,autoincrement=True)
greg = db.Column(db.Date())
hdate_str = db.Column(db.String())
hdate_str_heb = db.Column(db.String())
student = db.relationship("Student",uselist=False)
student_id = db.Column(db.Integer,db.ForeignKey('students.id'))
class Pessoa(db.Model):
__tablename__ = 'pessoas'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String())
cpf = db.Column(db.String())
datanascimento = db.Column(db.Date())
email = db.Column(db.String())
telefones = db.relationship('Telefone', backref='telefones')
class Movie(db.Model):
def __init__(self, title, release_date):
self.title = title
self.release_date = release_date
title = db.Column(db.String(64), nullable=False, unique=True)
release_date = db.Column(db.Date(), nullable=False, unique=False)
actors = db.relationship("Actor",
secondary=movies_actors,
back_populates="movies")
class Article(db.Base):
__tablename__ = 'articles'
id = db.Column(db.String(50),
primary_key=True,
default=lambda: str(uuid.uuid4()))
owner_id = db.Column(db.String(50), nullable=False)
owner_type = db.Column(db.String(10), nullable=False)
url = db.Column(db.String(2048), nullable=False)
title = db.Column(db.String(512), nullable=False)
summary = db.Column(db.String(200))
date = db.Column(db.Date())
def __init__(self):
pass
def __str__(self):
return f'{self.url} : {self.title}'
class News(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(1000))
content = db.Column(db.String(2000))
date_issued = db.Column(db.Date())
publisher_name = db.Column(db.String(100), db.ForeignKey('publisher.name'))
publisher = db.relationship('Publisher',
backref=db.backref('news', lazy='dynamic'))
def __init__(self, title, content, date_issued, publisher):
self.title = title
self.content = content
self.date_issued = date_issued
self.publisher = publisher
def __repr__(self):
return self.title
class Serial(db.Model):
__tablename__ = "serials"
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.Integer)
timestamp = db.Column(db.DateTime(), index=True, default=datetime.utcnow)
date = db.Column(db.Date(), default=datetime.utcnow().date)
name = db.Column(db.String(300), nullable=True)
n = db.Column(db.Boolean)
p = db.Column(db.Boolean)
# stands for proccessed , which be modified after been processed
pdt = db.Column(db.DateTime())
# Fix: adding pulled by feature to tickets
pulledBy = db.Column(db.Integer)
office_id = db.Column(db.Integer, db.ForeignKey('offices.id'))
task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'))
def __init__(self, number=100,
office_id=1,
task_id=1, pulledBy = 01,
name=None, n=False, p=False):
class User(db.Model, UserMixin):
"""
User model building off of flask-registration
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(60))
password = db.Column(db.String())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String())
current_login_ip = db.Column(db.String())
login_count = db.Column(db.Integer())
created = db.Column(db.Date())
company = db.Column(db.String)
apis = db.relationship('API',
secondary=apis,
backref=db.backref('apis', lazy='dynamic'))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('user'))
onboarded = db.Column(db.Boolean(), default=False)
returning_visitors = db.relationship('GoogleAnalyticsReturningVisitors',
secondary=returning_visitors,
backref=db.backref('user'))
signups = db.relationship('GoogleAnalyticsSignups',
secondary=signups,
backref=db.backref('user'))
def __repr__(self):
return '<User %s>' % self.email
def as_dict(self):
return {
'email': self.email,
'roles': [str(role) for role in self.roles],
'onboarded': self.onboarded
}
class API1(db.Model):
id = db.Column(db.Integer, primary_key=True)
countrycode = db.Column(db.String(4))
date = db.Column(db.Date())
cases = db.Column(db.Integer())
deaths = db.Column(db.Integer())
recovered = db.Column(db.Integer())
def __init__(self, countrycode, date, cases, deaths, recovered):
self.countrycode = countrycode
self.date = date
self.cases = cases
self.deaths = deaths
self.recovered = recovered
def __repr__(self):
return '<Country %r>' % self.countrycode
def as_dict(self):
dictionary = {
c.name: getattr(self, c.name)
for c in self.__table__.columns
}
return dictionary
class UserReading(db.Model):
__tablename__ = 'UserReading'
id = db.Column(db.Integer, primary_key=True)
userId = db.Column(db.String())
readingRate = db.Column(db.Integer)
currentBook = db.Column(db.String())
currentChp = db.Column(db.Integer)
nextBook = db.Column(db.String())
nextChp = db.Column(db.Integer)
today = db.Column(db.Date())
offset = db.Column(db.Integer)
def __init__(self, userId):
self.userId = userId
self.readingRate = None
self.currentBook = None
self.currentChp = None
self.nextBook = None
self.nextChp = None
self.today = None
self.offset = None
def __repr__(self):
return '<id {}>'.format(self.id)
class AttendanceModel(db.Model):
__tablename__ = "attendances"
id = db.Column(db.Integer, primary_key=True)
student_id = db.Column(db.Integer,
db.ForeignKey("students.id"),
nullable=False)
school_id = db.Column(db.Integer,
db.ForeignKey("schools.id"),
nullable=False)
grade = db.Column(
db.Enum("KG",
"G-1",
"G-2",
"G-3",
"G-4",
"G-5",
"G-6",
"G-7",
"G-8",
"G-9",
"G-10",
"G-11",
"G-12",
name="grade"))
year = db.Column(db.Integer, nullable=False)
enrolled_date = db.Column(db.Date(), nullable=True)
school = relationship("SchoolModel", foreign_keys=[school_id])
student = relationship("StudentModel", foreign_keys=[student_id])
def __init__(self, student_id: str, school_id: str, grade: str, year: str,
enrolled_date: date) -> None:
self.student_id = student_id
self.school_id = school_id
self.grade = grade
self.year = year
self.enrolled_date = enrolled_date
def __repr__(self):
return f"<Attendance for student id: {self.student_id}>"
def attendance_dict(self, school: SchoolModel, student: StudentModel):
"""
Return object data for viewing easily serializable format
:param school:
:param student:
:return:
"""
return {
"id": self.id,
"grade": self.grade,
"year": self.year,
"enrolled_date": self.enrolled_date.strftime("%d-%m-%Y"),
"school": school.school_dict(),
"student": student.student_dict()
}
@staticmethod
def create_attendance(new_attendance) -> bool:
"""
create new_attendance
:param new_attendance:
:return: bool
"""
try:
db.session.add(new_attendance)
db.session.commit()
return new_attendance.id
except SQLAlchemyError as error:
db.session.rollback()
raise error
@staticmethod
def get_all_attendance() -> List[AttendanceModel]:
"""
get all Attendance records
:return: Attendance list
"""
try:
return db.session.query(AttendanceModel, SchoolModel, StudentModel).\
filter(AttendanceModel.school_id == SchoolModel.id).\
filter(AttendanceModel.student_id == StudentModel.id).all()
except SQLAlchemyError as error:
raise error
@staticmethod
def get_attendance_by_id(attendance_id: int) -> List[AttendanceModel]:
"""
get all Attendance records
:param attendance_id
:return: Attendance list
"""
try:
return db.session.query(AttendanceModel, SchoolModel, StudentModel). \
filter(AttendanceModel.school_id == SchoolModel.id). \
filter(AttendanceModel.student_id == StudentModel.id).\
filter(AttendanceModel.id == attendance_id)
except SQLAlchemyError as error:
raise error
@staticmethod
def delete_attendance_by_id(attendance_id: int) -> bool:
"""
delete Attendance by id
:param attendance_id:
:return:
"""
try:
if not db.session.query(AttendanceModel).filter(
AttendanceModel.id == attendance_id).delete():
return False
db.session.commit()
return True
except SQLAlchemyError as error:
db.session.rollback()
raise error
@staticmethod
def update_attendance(attendance_id: int,
attendance: AttendanceModel) -> bool:
"""
update attendance info by id
:param attendance_id:
:param attendance:
:return: bool
"""
try:
target_attendance = db.session.query(AttendanceModel).filter(
AttendanceModel.id == attendance_id).first()
if not target_attendance:
raise SQLCustomError("No record for requested attendance")
target_attendance.student_id = attendance.student_id
target_attendance.school_id = attendance.school_id
target_attendance.grade = attendance.grade
target_attendance.year = attendance.year
target_attendance.enrolled_date = attendance.enrolled_date
db.session.commit()
return True
except SQLAlchemyError as error:
db.session.rollback()
raise error
class Stat(db.Model):
__tablename__ = 'stat'
id = db.Column(db.Integer, primary_key=True)
profile_id = db.Column(db.Integer, db.ForeignKey('profile.id'))
rank = db.Column(db.Integer)
stat_date = db.Column(db.Date())
class StudentModel(db.Model):
__tablename__ = "students"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
deactivated_at = db.Column(db.DateTime(), nullable=True)
birth_date = db.Column(db.Date(), nullable=True)
father_name = db.Column(db.UnicodeText())
mother_name = db.Column(db.UnicodeText())
parents_occupation = db.Column(db.Text())
photo = db.Column(db.Text())
address_id = db.Column(db.Integer,
db.ForeignKey("addresses.id"),
nullable=False)
address = relationship("AddressModel", foreign_keys=[address_id])
def __init__(self, name: str, deactivated_at: datetime, birth_date: date,
father_name: str, mother_name: str, parents_occupation: str,
photo: str, address_id: int):
self.name = name
self.deactivated_at = deactivated_at
self.birth_date = birth_date
self.father_name = father_name
self.mother_name = mother_name
self.parents_occupation = parents_occupation
self.photo = photo
self.address_id = address_id
def __repr__(self):
return f"<Student {self.name}>"
def student_dict(self) -> Dict[str, Any]:
"""
Return object data in easily serializable format
"""
return {
"id":
self.id,
"name":
self.name,
"deactivated_at":
self.deactivated_at.strftime("%d-%m-%Y")
if self.deactivated_at else "",
"birth_date":
self.birth_date.strftime("%d-%m-%Y") if self.birth_date else "",
"father_name":
self.father_name,
"mother_name":
self.mother_name,
"parents_occupation":
self.parents_occupation,
"photo":
self.photo,
"address": {
"id": self.address_id,
"division": self.address.division,
"district": self.address.district,
"township": self.address.township,
"street_address": self.address.street_address
}
}
@staticmethod
def get_student_by_id(student_id: int) -> Optional[StudentModel]:
"""
get student by id
:param student_id:
:return: student info
"""
try:
return db.session.query(StudentModel). \
join(AddressModel). \
filter(StudentModel.id == student_id).first()
except SQLAlchemyError as error:
raise error
@staticmethod
def get_students_by_name(name) -> List[StudentModel]:
"""
get students by name (as name is not unique, multiple records can be returned)
:param name:
:return: student info list
"""
try:
return db.session.query(StudentModel).join(AddressModel).filter(
StudentModel.name == name)
except SQLAlchemyError as error:
raise error
@staticmethod
def get_students_by_birth_date(birth_date) -> List[StudentModel]:
"""
get students by birth_date (as birth_date is not unique, multiple records can be returned)
:param birth_date:
:return: student info list
"""
try:
return db.session.query(StudentModel).join(AddressModel).filter(
StudentModel.birth_date == birth_date)
except SQLAlchemyError as error:
raise error
@staticmethod
def get_all_students(page) -> Pagination:
"""
get all students
:return: students list of dict
"""
try:
return db.session.query(StudentModel).join(AddressModel).\
paginate(page=page, error_out=False)
except SQLAlchemyError as error:
raise error
@staticmethod
def get_all_student_address(page) -> Pagination:
"""
get all school address for get all address API
:params page
:return
"""
try:
return db.session.query(AddressModel, StudentModel). \
filter(AddressModel.id == StudentModel.address_id).filter(
AddressModel.type == "student").paginate(page=page, error_out=False)
except SQLAlchemyError as error:
raise error
@staticmethod
def create_student(new_student):
"""
create new student
:param new_student:
:return: bool
"""
try:
db.session.add(new_student)
db.session.commit()
return new_student.id
except SQLAlchemyError as error:
db.session.rollback()
raise error
@staticmethod
def update_student(student_id, student) -> bool:
"""
update student info by id
:param student_id:
:param student:
:return: bool
"""
try:
target_student = db.session.query(StudentModel).filter(
StudentModel.id == student_id).first()
if not target_student:
raise SQLCustomError("No record for requested student")
target_student.name = student.name
target_student.deactivated_at = student.deactivated_at
target_student.birth_date = student.birth_date
target_student.father_name = student.father_name
target_student.mother_name = student.mother_name
target_student.parents_occupation = student.parents_occupation
target_student.photo = student.photo
target_student.address_id = student.address_id
db.session.commit()
return True
except SQLAlchemyError as error:
db.session.rollback()
raise error
@staticmethod
def delete_student(student_id) -> bool:
"""
delete student by id
:param student_id:
:return: bool
"""
try:
if not db.session.query(StudentModel).filter(
StudentModel.id == student_id).delete():
return False
db.session.commit()
return True
except SQLAlchemyError as error:
db.session.rollback()
raise error
class StudentModel(db.Model):
__tablename__ = "students"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
deactivated_at = db.Column(db.DateTime(), nullable=True)
birth_date = db.Column(db.Date(), nullable=True)
father_name = db.Column(db.UnicodeText())
mother_name = db.Column(db.UnicodeText())
parents_occupation = db.Column(db.Text())
address_id = db.Column(db.Integer, db.ForeignKey("addresses.id"), nullable=False)
address = relationship("AddressModel", foreign_keys=[address_id])
def __init__(self, name: str,
deactivated_at: datetime, birth_date: date, father_name: str, mother_name: str,
parents_occupation: str, address_id: int):
self.name = name
self.deactivated_at = deactivated_at
self.birth_date = birth_date
self.father_name = father_name
self.mother_name = mother_name
self.parents_occupation = parents_occupation
self.address_id = address_id
def __repr__(self):
return f"<Student {self.name}>"
def student_dict(self) -> Dict[str, Any]:
"""
Return object data in easily serializable format
"""
return {
"id": self.id,
"name": self.name,
"deactivated_at": self.deactivated_at.strftime("%d-%m-%Y") if self.deactivated_at else "",
"birth_date": self.birth_date.strftime("%d-%m-%Y") if self.birth_date else "",
"father_name": self.father_name,
"mother_name": self.mother_name,
"parents_occupation": self.parents_occupation,
"address": {
"id": self.address_id,
"division": self.address.division,
"district": self.address.district,
"township": self.address.township,
"street_address": self.address.street_address
}
}
@staticmethod
def create_student(new_student):
"""
create new student
:param new_student:
:return: bool
"""
try:
db.session.add(new_student)
db.session.commit()
return True
except SQLAlchemyError as e:
# to put log
return False
class Student(db.Model):
__tablename__ = "students"
id = db.Column(db.Integer(),primary_key=True)
school = db.relationship("School",back_populates ="students",uselist=False)
hebSchool = db.relationship("HebSchool",back_populates ="students",uselist=False) #way to make non-list?
dob = db.Column(db.Date())
email=db.Column(db.String())
childName=db.Column(db.String())
ranking_main=db.Column(db.Integer())
ranking_familyMinyan=db.Column(db.Integer())
ranking_torahInTheRound=db.Column(db.Integer())
atVenue = db.Column(db.Boolean())
over200 = db.Column(db.Boolean())
accommodation_other = db.Column(db.Text)
twin = db.Column(db.Boolean())
school_id = db.Column(db.Integer,db.ForeignKey('schools.id'))
hebSchool_id = db.Column(db.Integer,db.ForeignKey('hebschools.id'))
nonDates = db.relationship("NonDate",back_populates="student",uselist=True)
birthdayDD =db.Column(db.Text)
bmDD = db.Column(db.Text)
def __init__(self,rankings,schoolId,school,hebSchoolId,hebSchool,DOB,DOBdd,BMdd,nonDates=[],accommodation=False, **kwargs):
super(Student, self).__init__(**kwargs)
self.ranking_main=rankings[0]['value']
self.ranking_familyMinyan=rankings[1]['value']
self.ranking_torahInTheRound=rankings[2]['value']
self.dob=parse(DOB).date()
self.birthdayDD = json.dumps(DOBdd)
self.bmDD = json.dumps(BMdd)
self.nonDates=[]
# for nonDate in nonDates:
# greg = nonDate['greg']
# gdate = date(greg['year'],greg['month'],greg['day'])
# nd = NonDate(greg=gdate)
# nd.student_id = self.id
# self.nonDates.append(nd)
# nd.student=self
# print("APPENDING non-DATE")
# print(f"My id is: {self.id}")
# db.session.add(nd)
# gregs=[nonDate['greg'] for nonDate in nonDates]
# self.nonDates=NonDate.cls_construct(gregs)
def approx_bm_dd_str(self):
BMdd=json.loads(self.bmDD)
return parse(BMdd['hgregorian']).strftime('%m/%d/%Y') + " (" + BMdd['hdate_str'] + "/" + BMdd['hdate_str_heb'] + ")"
def birthday_dd_str(self):
DOBdd=json.loads(self.birthdayDD)
return self.dob.strftime('%m/%d/%Y') + " (" + DOBdd['hdate_str'] + "/" + DOBdd['hdate_str_heb'] + ")"
def non_date_string(self):
nds = [nd.greg.strftime('%m/%d/%Y') for nd in self.nonDates]
return ", ".join(nds)
def to_dict(self):
nds=[{'hgregorian':nd.greg,'hdate_str':nd.hdate_str,'hdate_str_heb':nd.hdate_str_heb} for nd in self.nonDates]
d = {'email': self.email,
'childName':self.childName,
'school':self.school.name,
'schoolId':self.school.id,
'hebSchool':self.hebSchool.name,
'hebSchoolId':self.hebSchool.id,
'DOB':self.dob,
'DOBdd':json.loads(self.birthdayDD),
'BMdd':json.loads(self.bmDD),
'rankings':[{
'name': "Main Sanctuary",
'value': self.ranking_main
},
{
'name': "Family Minyan",
'value': self.ranking_familyMinyan
},
{
'name': "Torah In The Round",
'value': self.ranking_torahInTheRound
}],
'atVenue':self.atVenue,
'over200':self.over200,
'nonDates':nds,
'accommodation':self.accommodation_other != '',
'accommodation_other':self.accommodation_other,
'twin':self.twin,
}
return d
def to_csv_row(self):
a_row = [self.email, self.childName, self.birthday_dd_str(), self.school.name, self.hebSchool.name, self.atVenue, self.over200, self.twin, self.accommodation_other,]
a_row.append(self.approx_bm_dd_str())
a_row.append("Main: {}, Family Minyan: {}, Torah in the Round: {}".format(self.ranking_main,self.ranking_familyMinyan,self.ranking_torahInTheRound))
a_row.append(self.non_date_string())
return a_row
class Exam(db.Model):
__tablename__ = "exams"
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(), nullable=False)
photo_url = db.Column(db.String(), nullable=False)
procedure_code = db.Column(db.String(), nullable=True)
date_for_receipt = db.Column(db.Date())
cut_off_date = db.Column(db.Date())
fk_exam_types_id = db.Column(db.Integer,
db.ForeignKey("exam_types.id"),
nullable=False)
exam_type = db.relationship("ExamType",
foreign_keys="Exam.fk_exam_types_id")
fk_locations_id = db.Column(db.Integer,
db.ForeignKey("locations.id"),
nullable=False)
location = db.relationship("Location", foreign_keys="Exam.fk_locations_id")
fk_providers_id = db.Column(db.Integer,
db.ForeignKey("providers.id"),
nullable=False)
provider = db.relationship("Provider", foreign_keys="Exam.fk_providers_id")
fk_health_plans_id = db.Column(db.Integer,
db.ForeignKey("health_plans.id"),
nullable=False)
health_plan = db.relationship("HealthPlan",
foreign_keys="Exam.fk_health_plans_id")
items = db.relationship("ExamItem", uselist=True)
fk_users_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
user = db.relationship("User", foreign_keys="Exam.fk_users_id")
created_at = db.Column(db.DateTime())
updated_at = db.Column(db.DateTime())
def save(self):
try:
db.session.add(self)
db.session.commit()
except Exception as ex:
db.session.rollback()
print(ex)
raise Exception("Ocorreu um erro ao inserir local de atendimento!")
def delete(self):
db.session.query(Exam.id == self.id).delete()
db.session.commit()
def json(self):
return {"id": self.id}
@classmethod
def find_by_id(cls, id):
return db.session.query(cls).filter(cls.id == id).first()
# -----------------------------------------------------
# GRAPHQL
# -----------------------------------------------------
@classmethod
def resolve_exams(cls, authorizedUser, **kwargs):
query = db.session.query(Exam)
id, description, page_index, page_size = (
kwargs.get("id"),
kwargs.get("l_description"),
kwargs.get("page_index", 0),
kwargs.get("page_size", 10),
)
provider_id = kwargs.get("provider_id")
location_id = kwargs.get("location_id")
exam_type_id = kwargs.get("exam_type_id")
begin = kwargs.get("begin")
end = kwargs.get("end")
query = query.filter(cls.fk_users_id == authorizedUser.id)
if id is not None:
query = query.filter(Exam.id == id)
if provider_id is not None:
query = query.filter(cls.fk_providers_id == provider_id)
if location_id is not None:
query = query.filter(cls.fk_locations_id == location_id)
if exam_type_id is not None:
query = query.filter(cls.fk_exam_types_id == exam_type_id)
if begin is not None:
query = query.filter(cls.created_at >= begin)
if end is not None:
query = query.filter(cls.created_at <= end)
if description is not None:
query = query.filter(Exam.description.like(f"%{description}%"))
return query.offset(page_index * page_size).limit(page_size)
@classmethod
def resolve_exam(cls, authorizedUser, **kwargs):
query = db.session.query(Exam)
query = query.filter(cls.fk_users_id == authorizedUser.id)
id = kwargs.get("id")
return query.filter(Exam.id == id).first()
@classmethod
def resolve_pending_exams(cls, authorizedUser, **kwargs):
page_index, page_size = (
kwargs.get("page_index", 0),
kwargs.get("page_size", 10),
)
query = db.session.query(cls) \
.outerjoin(cls.items)
query = query.filter(cls.fk_users_id == authorizedUser.id)
# Exames sem data para recebimento, exames sem data de corte, exames com procedimentos sem custo definido
query = query.filter(
or_(cls.date_for_receipt == None, cls.cut_off_date == None,
ExamItem.cost == None))
return query.offset(page_index * page_size).limit(page_size)
class Organization(db.Model):
__tablename__ = "organizations"
id = db.Column(db.Integer, primary_key=True)
cpf_cnpj = db.Column(db.String(256), index=True, unique=True)
description = db.Column(db.String(256))
created_at = db.Column(db.Date())
updated_at = db.Column(db.Date())
users = db.relationship("User", uselist=True)
locations = db.relationship("Location", uselist=True)
providers = db.relationship("Provider", uselist=True)
exam_types = db.relationship("ExamType", uselist=True)
def __init__(self, *args, **kwargs):
self.id = None
self.cpf_cnpj = kwargs.get("cpf_cnpj", None)
self.description = kwargs.get("description", None)
self.created_at = kwargs.get("created_at", datetime.now())
self.updated_at = kwargs.get("updated_at", datetime.now())
if self.cpf_cnpj is None:
raise Exception("Informe o CPF ou CNPJ!")
elif self.description is None:
raise Exception("Informe a descrição!")
def json(self):
return {
"id": self.id,
"cpf_cnpj": self.cpf_cnpj,
"description": self.description,
"created_at": self.created_at,
"updated_at": self.updated_at,
}
def save(self):
print("Saving Organization")
db.session.add(self)
db.session.commit()
@classmethod
def find_by_id(cls, id):
return db.session.query(cls).filter(cls.id == id).first()
@classmethod
def resolve_organizations(cls, **kwargs):
query = db.session.query(Organization)
id, page_index, page_size = (
kwargs.get("id"),
kwargs.get("page_index", 0),
kwargs.get("page_size", 10),
)
if id is not None:
query = query.filter(Organization.id == id)
return query.offset(page_index * page_size).limit(page_size)
@classmethod
def resolve_organization(cls, **kwargs):
query = db.session.query(Organization)
id = kwargs.get("id")
return query.filter(Organization.id == id).first()
