def update_transfer_by_id(self, transfer_id: int, data: Dict[str,
str]) -> bool:
"""
update transfer by id
:param transfer_id:
:param data:
:return:
"""
if not transfer_id or not data:
raise RequestDataEmpty("Transfer data is empty")
if not self.input_validate.validate_json(data, transfer_schema):
self.logger.error("All transfer field input must be required.")
raise ValidateFail("Transfer update validation fail")
try:
self.logger.info("Update transfer info by id %s", transfer_id)
return TransferModel.update_transfer(
transfer_id,
TransferModel(year=int(data["year"]),
month=data["month"],
total_jpy=int(data["total_jpy"]),
total_mmk=int(data["total_mmk"])))
except SQLAlchemyError as error:
self.logger.error(
"Transfer update fail. id %s, error %s, custom error: %s",
transfer_id, traceback.format_exc(), error)
raise SQLCustomError(description="Update transfer by ID SQL ERROR")
except SQLCustomError as error:
self.logger.error(
"Transfer update fail. id %s, error %s, custom error: %s",
transfer_id, traceback.format_exc(), error)
raise SQLCustomError(description="No record for requested address")
def update_attendance_by_id(self, attendance_id: int, data: Dict) -> bool:
"""
put attendance by id
:param attendance_id:
:param data:
:return:
"""
if not data:
raise RequestDataEmpty("Attendance data is empty")
if not self.input_validate.validate_json(data, attendance_schema):
self.logger.error("All attendance field input must be required.")
raise ValidateFail("Attendance update validation fail")
try:
self.logger.info("Update attendance info by attendance_id:{}".format(attendance_id))
return AttendanceModel.update_attendance(attendance_id, AttendanceModel(
student_id=data["student_id"],
school_id=data["school_id"],
grade=data["grade"],
year=data["year"],
enrolled_date=data["enrolled_date"]))
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="Update attendance by ID SQL ERROR")
except SQLCustomError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="No record for requested attendance")
def update_school_by_id(self, school_id: int, data: Dict) -> bool:
"""
update school by id
:param school_id:
:param data:
:return:
"""
if not data:
raise RequestDataEmpty("school data is empty")
if not self.input_validate.validate_json(data, school_schema):
self.logger.error("All school field input must be required.")
raise ValidateFail("School update validation fail")
try:
self.logger.info(
"update school info by school_id:{}".format(school_id))
return SchoolModel.update_school(
school_id,
SchoolModel(name=data["school_name"],
contact_info=data["contact_info"],
address_id=data["address_id"]))
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="Update school by ID SQL ERROR")
except SQLCustomError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="No record for requested school")
def update_student_by_id(self, student_id: int, data: Dict) -> bool:
"""
put student by id
:param student_id:
:param data:
:return:
"""
if not data:
raise RequestDataEmpty("Student data is empty")
if not self.input_validate.validate_json(data, student_schema):
self.logger.error("All student field input must be required.")
raise ValidateFail("Student update validation fail")
try:
self.logger.info(
"Update student info by student_id:{}".format(student_id))
return StudentModel.update_student(
student_id,
StudentModel(name=data["name"],
deactivated_at=data["deactivated_at"],
birth_date=data["birth_date"],
father_name=data["father_name"],
mother_name=data["mother_name"],
parents_occupation=data["parents_occupation"],
photo=data["photo"],
address_id=data["address_id"]))
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="Update student by ID SQL ERROR")
except SQLCustomError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="No record for requested student")
def update_address_by_id(self, address_id: int, data: Dict[str, str]) -> bool:
"""
update address by id
:param address_id:
:param data:
:return:
"""
if not address_id or not data:
raise RequestDataEmpty("Address data is empty")
if not self.input_validate.validate_json(data, address_schema):
self.logger.error("All address field input must be required.")
raise ValidateFail("Address update validation fail")
try:
self.logger.info("update address info by id %s", address_id)
return AddressModel.update_address(address_id, AddressModel(
division=data["division"],
district=data["district"],
township=data["township"],
street_address=data["street_address"],
type=data["type"]))
except SQLAlchemyError as e:
self.logger.error("Address update fail. id %s, error %s, custom error: %s", address_id,
traceback.format_exc(), e)
raise SQLCustomError(description="Update address by ID SQL ERROR")
except SQLCustomError as e:
self.logger.error("Address update fail. id %s, error %s, custom error: %s", address_id,
traceback.format_exc(), e)
raise SQLCustomError(description="No record for requested address")
def update_user_by_id(self, user_id: int, data: Dict[str, Any]) -> bool:
"""
update user by id
:param user_id:
:param data:
:return:
"""
if not data:
raise RequestDataEmpty("user data is empty")
if not self.input_validate.validate_json(data, user_schema):
self.logger.error("All user field input must be required.")
raise ValidateFail("User update validation fail")
try:
self.logger.info("update user info by id %s", user_id)
return UserModel.update_user(
user_id,
UserModel(name=data["name"],
email=data["email"],
address_id=data["address_id"],
hashed_password=generate_password_hash(
data["password"]),
role=data["role"],
country=data["country"],
donation_active=data["donation_active"]))
except SQLAlchemyError:
self.logger.error("User update fail. id %s, error %s", user_id,
traceback.format_exc())
raise SQLCustomError(description="Update user by ID SQL ERROR")
except SQLCustomError as error:
self.logger.error(
"User update fail. id %s, error %s, custom error: %s", user_id,
traceback.format_exc(), error)
raise SQLCustomError(description="No record for requested user")
def update_extra_fund_by_id(self, extra_fund_id: int,
data: Dict[str, str]) -> bool:
"""
update extra fund by id
:param extra_fund_id:
:param data:
:return:
"""
if not extra_fund_id or not data:
raise RequestDataEmpty("Extra fund data is empty")
if not self.input_validate.validate_json(data, extra_funds_schema):
self.logger.error("All extra fund field input must be required.")
raise ValidateFail("Extra fund update validation fail")
try:
self.logger.info("Update extra fund info by id %s", extra_fund_id)
return ExtraFundsModel.update_extra_fund(
extra_fund_id,
ExtraFundsModel(mmk_amount=int(data["mmk_amount"]),
transfer_id=int(data["transfer_id"])))
except SQLAlchemyError as e:
self.logger.error(
"Extra fund update fail. id %s, error %s, custom error: %s",
extra_fund_id, traceback.format_exc(), e)
raise SQLCustomError(
description="Update extra fund by ID SQL ERROR")
except SQLCustomError as e:
self.logger.error(
"Extra fund update fail. id %s, error %s, custom error: %s",
extra_fund_id, traceback.format_exc(), e)
raise SQLCustomError(
description="No record for requested extra fund")
def update_donation_by_id(self, donation_id: int, data: Dict) -> bool:
"""
put donation by id
:param donation_id:
:param data:
:return:
"""
if not data:
raise RequestDataEmpty("Donation data is empty")
if not self.input_validate.validate_json(data, donation_schema):
self.logger.error("All donation field input must be required.")
raise ValidateFail("Donation update validation fail")
try:
self.logger.info("Update donation info by donation_id:{}".format(donation_id))
return DonationModel.update_donation(donation_id, DonationModel(
user_id=data["user_id"],
attendance_id=data["attendance_id"],
transfer_id=data["transfer_id"],
year=data["year"],
month=data["month"],
mmk_amount=data["mmk_amount"],
jpy_amount=data["jpy_amount"],
paid_at=data["paid_at"]))
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="Update donation by ID SQL ERROR")
except SQLCustomError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="No record for requested donation")
def get_address_by_id(self, address_id: int) -> Dict[str, Any]:
"""
get users by id
:return: address list of dict
"""
self.logger.info("Get address by id %s", address_id)
try:
address = AddressModel.get_address_by_id(address_id)
if not address:
raise SQLCustomError(description="No data for requested address id: {}".format(address_id))
return address.as_dict()
except SQLAlchemyError:
self.logger.error("Get address by id fail. id %s. error %s", address_id, traceback.format_exc())
raise SQLCustomError(description="GET address by ID SQL ERROR")
def get_student_by_id(self, student_id: int) -> Optional[Dict]:
"""
get student info by id
:param student_id:
:return: student list of dict
"""
try:
self.logger.info("Get student info by student_id:{}".format(student_id))
student = StudentModel.get_student_by_id(student_id)
if not student:
raise SQLCustomError(description="No data for requested student id: {}".format(student_id))
return student.student_dict()
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="GET student by ID SQL ERROR")
def get_user_by_id(self, user_id: int) -> Dict[str, Any]:
"""
get users by id
:return: users list of dict
"""
self.logger.info("Get users list by id %s", user_id)
try:
user = UserModel.get_user_by_id(user_id)
if not user:
raise SQLCustomError(description="No data for requested user id: {}".format(user_id))
return user.as_dict()
except SQLAlchemyError:
self.logger.error("Get users by id fail. id %s. error %s", user_id,
traceback.format_exc())
raise SQLCustomError(description="GET user by ID SQL ERROR")
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
def create_user(self, data: Dict[str, Any]) -> int:
"""
create school records
:param data:
:return: created user id
"""
if not data:
raise RequestDataEmpty("user data is empty")
if not self.input_validate.validate_json(data, user_schema):
self.logger.error("All user field input must be required.")
raise ValidateFail("User validation fail")
try:
return UserModel.create_user(
UserModel(name=data["name"],
email=data["email"],
address_id=data["address_id"],
hashed_password=generate_password_hash(
data["password"]),
role=data["role"],
country=data["country"],
donation_active=data["donation_active"]))
except SQLAlchemyError:
self.logger.error("User create fail. email %s, error %s",
data.get("email"), traceback.format_exc())
raise SQLCustomError("Create User Error")
def get_attendance_by_id(self, attendance_id: int) -> Optional[List]:
"""
get attendance info by id
:param attendance_id:
:return: attendance list of dict
"""
try:
self.logger.info("Get attendance info by attendance_id:{}".format(attendance_id))
attendance_by_id = AttendanceModel.get_attendance_by_id(attendance_id)
if not attendance_by_id:
raise SQLCustomError(description="No data for requested attendance id: {}".format(attendance_id))
attendance, school, student = attendance_by_id
return attendance.attendance_dict(school, student)
except SQLAlchemyError:
self.logger.error("Error: {}".format(traceback.format_exc()))
raise SQLCustomError(description="GET Attendance by ID SQL ERROR")
def get_all_addresses(
self,
page: int = 1,
per_page: int = 20,
address_type: str = None) -> (List[Dict[str, Any]], int):
"""
get all addresses
:params page int
:params per_page int
:params address_type int
:return:
"""
try:
if address_type:
addresses, address_records = self.__return_address_types(
page, per_page, address_type)
else:
addresses = AddressModel.get_all_addresses(page, per_page)
address_records = self.__get_all_address_records(addresses)
if address_records is None:
self.logger.error(
"Address type should be school or user or student")
raise ThingahaCustomError(
"Address type should be school or user or student")
return self.__return_addresses_with_format(addresses,
address_records)
except SQLAlchemyError:
self.logger.error("Get all addresses fail. error %s",
traceback.format_exc())
raise SQLCustomError(description="GET address SQL ERROR")
def get_all_donator_donations_records(self,
user_id: int,
page: int = 1,
per_page: int = 20) -> (List, Any):
"""
get all donation
:params page
:params per_page
:return: donation list of dict
"""
try:
self.logger.info("Get Donation list")
donations = DonationModel.get_all_donator_donations(
user_id, page, per_page)
return {
"donations": [
donation.donation_dict(user, student)
for donation, user, student in donations.items
],
"total_count":
donations.total,
"current_page":
donations.page,
"next_page":
donations.next_num,
"prev_page":
donations.prev_num,
"pages":
donations.pages
}
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="GET Donation SQL ERROR")
def get_students_by_query(
self,
page: int,
query: str,
per_page: int = 20) -> (List[Dict[str, Any]], int):
"""
get student by query (name, father_name, mother_name and parents_occupation)
:param query
:param page
:param per_page
:return: users list of dict
"""
self.logger.info("Get students list by query %s", query)
try:
students = StudentModel.get_students_by_query(
page, query, per_page)
return {
"students": self.__return_student_list(students.items),
"total_count": students.total,
"current_page": students.page,
"next_page": students.next_num,
"prev_page": students.prev_num,
"pages": students.pages
}
except SQLAlchemyError:
self.logger.error("Get students by name fail. query %s. error %s",
query, traceback.format_exc())
raise SQLCustomError(description="GET students by query SQL ERROR")
def create_student(self, data: Dict[str, Any]) -> int:
"""
create school records
:param data:
:return: created student id
"""
if not data:
raise RequestDataEmpty("Student data is empty")
if not self.input_validate.validate_json(data, student_schema):
self.logger.error("All student field input must be required.")
raise ValidateFail("Student validation fail")
try:
uploaded_photo_url = self.upload_file(
data["photo"]) if data.get("photo") else None
return StudentModel.create_student(
StudentModel(name=data["name"],
deactivated_at=data["deactivated_at"],
birth_date=data["birth_date"],
father_name=data["father_name"],
gender=data["gender"],
mother_name=data["mother_name"],
parents_occupation=data["parents_occupation"],
photo=uploaded_photo_url,
address_id=data["address_id"]))
except SQLAlchemyError as error:
self.logger.error(
"Student create fail. name %s, error %s, format: %s ",
data["name"], error, traceback.format_exc())
raise SQLCustomError("Student create fail")
def get_all_attendances(self, page: int, grade: str, year: int, per_page: int = 20) -> (List, Any):
"""
get all attendance
:params page
:params grade
:params year
:params per_page
:return: attendance list of dict
"""
try:
if year and not grade:
attendances = AttendanceModel.get_attendances_by_year(page, year, per_page)
elif grade and not year:
attendances = AttendanceModel.get_attendances_by_grade(page, grade, per_page)
elif year and grade:
attendances = AttendanceModel.get_attendances_by_grade_year(page, grade, year, per_page)
else:
attendances = AttendanceModel.get_all_attendances(page, per_page)
return {
"attendances": [attendance.attendance_dict(school, student) for attendance, school, student in
attendances.items],
"total_count": attendances.total,
"current_page": attendances.page,
"next_page": attendances.next_num,
"prev_page": attendances.prev_num,
"pages": attendances.pages
}
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="GET Attendance SQL ERROR")
def create_address(self, data: Dict[str, str], flush: bool = False) -> int:
"""
create new address
:param data: data dict includes division, district, township, street_address
:param flush: default false
:return: True if creation success else False
"""
if not data:
raise RequestDataEmpty("Address data is empty")
if not self.input_validate.validate_json(data, address_schema):
self.logger.error("All address field input must be required.")
raise ValidateFail("Address validation fail")
try:
return AddressModel.create_address(AddressModel(
division=data["division"],
district=data["district"],
township=data["township"],
street_address=data["street_address"],
type=data["type"]),
flush=flush)
except SQLAlchemyError:
self.logger.error("Address create fail. error %s",
traceback.format_exc())
raise SQLCustomError("Address create fail")
def get_all_users(self, page: int = 1, role: str = None, country: str = None, per_page: int = 20) -> (List[Dict[str, Any]], int):
"""
get all users
:params: page page count
:params: role -> user role for filter
:params: country -> country for filter
:params: per_page
:return: users list of dict
"""
self.logger.info("Get all users list")
try:
if role and not country:
users = UserModel.get_users_by_role(page, role, per_page)
elif country and not role:
users = UserModel.get_users_by_country(page, country, per_page)
elif role and country:
users = UserModel.get_users_by_role_country(page, role, country, per_page)
else:
users = UserModel.get_all_users(page, per_page)
return {
"users": self.__return_user_list(users.items),
"total_count": users.total,
"current_page": users.page,
"next_page": users.next_num,
"prev_page": users.prev_num,
"pages": users.pages
}
except SQLAlchemyError:
self.logger.error("Get all users fail. error %s", traceback.format_exc())
raise SQLCustomError(description="GET user SQL ERROR")
def get_all_transfers(self,
page: int = 1,
per_page: int = 20) -> (List[Dict[str, Any]], int):
"""
get all transfers
:params: page
:params: per_page
:return:
"""
self.logger.info("Get all transfers list")
try:
transfers = TransferModel.get_all_transfers(page, per_page)
return {
"transfers":
[transfer.as_dict() for transfer in transfers.items],
"total_count": transfers.total,
"current_page": transfers.page,
"next_page": transfers.next_num,
"prev_page": transfers.prev_num,
"pages": transfers.pages
}
except SQLAlchemyError:
self.logger.error("Get all transfer fail. error %s",
traceback.format_exc())
raise SQLCustomError(description="GET transfer SQL ERROR")
def get_all_extra_funds(self,
page: int = 1,
per_page: int = 20) -> (List[Dict[str, Any]], int):
"""
get all extra_funds
:params page
:params per_page
:return:
"""
self.logger.info("Get all extra funds list")
try:
extra_funds = ExtraFundsModel.get_all_extra_funds(page, per_page)
return {
"extra_funds":
[extra_funds.as_dict() for extra_funds in extra_funds.items],
"total_count":
extra_funds.total,
"current_page":
extra_funds.page,
"next_page":
extra_funds.next_num,
"prev_page":
extra_funds.prev_num,
"pages":
extra_funds.pages,
"new_transfers":
self.get_new_transfers()
}
except SQLAlchemyError:
self.logger.error("Get all extra funds fail. error %s",
traceback.format_exc())
raise SQLCustomError(description="GET extra funds SQL ERROR")
def create_donation(self, data: Dict) -> int:
"""
create donation records
:param data:
:return: created donation id
"""
if not data:
raise RequestDataEmpty("Donation data is empty")
if not self.input_validate.validate_json(data, donation_schema):
self.logger.error("All donation field input must be required.")
raise ValidateFail("Donation validation fail")
try:
return DonationModel.create_donation(DonationModel(
user_id=data["user_id"],
attendance_id=data["attendance_id"],
transfer_id=data["transfer_id"],
year=data["year"],
month=data["month"],
mmk_amount=data["mmk_amount"],
jpy_amount=data["jpy_amount"],
paid_at=data["paid_at"]
))
except SQLAlchemyError as error:
self.logger.error("Donation create fail. error %s", error)
raise SQLCustomError("Donation create fail")
def get_schools_by_query(
self,
page: int,
query: str,
per_page: int = 20) -> Dict[str, Union[list, Any]]:
"""
get users by query (name, contact info)
:params page
:params query
:return: school list of dict
"""
self.logger.info("Get users list by query %s", query)
try:
schools = SchoolModel.get_schools_by_query(page, query, per_page)
return {
"schools": self.__return_school_list(schools.items),
"total_count": schools.total,
"current_page": schools.page,
"next_page": schools.next_num,
"prev_page": schools.prev_num,
"pages": schools.pages
}
except SQLAlchemyError:
self.logger.error("Get users by name fail. query %s. error %s",
query, traceback.format_exc())
raise SQLCustomError(description="GET schools by query SQL ERROR")
def get_users_by_query(self,
page: int,
query: str,
per_page: int = 20) -> (List[Dict[str, Any]], int):
"""
get users by query (name, email)
:param query
:param page
:param per_page
:return: users list of dict
"""
self.logger.info("Get users list by query %s", query)
try:
users = UserModel.get_users_by_query(page, query, per_page)
return {
"users": self.__return_user_list(users.items),
"total_count": users.total,
"current_page": users.page,
"next_page": users.next_num,
"prev_page": users.prev_num,
"pages": users.pages
}
except SQLAlchemyError:
self.logger.error("Get users by name fail. query %s. error %s",
query, traceback.format_exc())
raise SQLCustomError(description="GET user by query SQL ERROR")
def update_donation(donation_id: int, donation: DonationModel) -> bool:
"""
update donation info by id
:param donation_id:
:param donation:
:return: bool
"""
try:
target_donation = db.session.query(DonationModel).filter(
DonationModel.id == donation_id).first()
if not target_donation:
raise SQLCustomError("No record for requested donation")
target_donation.user_id = donation.user_id
target_donation.attendance_id = donation.attendance_id
target_donation.transfer_id = donation.transfer_id
target_donation.month = donation.month
target_donation.year = donation.year
target_donation.mmk_amount = donation.mmk_amount
target_donation.jpy_amount = donation.jpy_amount
target_donation.paid_at = donation.paid_at
db.session.commit()
return True
except SQLAlchemyError as error:
db.session.rollback()
raise error
def get_extra_fund_by_id(self, extra_fund_id: int) -> Dict[str, Any]:
"""
get extra fund by id
:return: extra fund list of dict
"""
self.logger.info("Get extra fund by id %s", extra_fund_id)
try:
extra_fund = ExtraFundsModel.get_extra_fund_by_id(extra_fund_id)
if not extra_fund:
raise SQLCustomError(
description="No data for requested extra funds id: {}".
format(extra_fund_id))
return extra_fund.as_dict()
except SQLAlchemyError:
self.logger.error("Get extra fund by id fail. id %s. error %s",
extra_fund_id, traceback.format_exc())
raise SQLCustomError(description="GET extra fund by ID SQL ERROR")
def get_school_by_id(self, school_id: int) -> Optional[Dict]:
"""
get school info by id
:param school_id:
:return: school list of dict
"""
try:
self.logger.info(
"Get school info by school_id:{}".format(school_id))
school = SchoolModel.get_school_by_id(school_id)
if not school:
raise SQLCustomError(
description="No data for requested school id: {}".format(
school_id))
return school.school_dict()
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="GET School by ID SQL ERROR")
def get_transfer_by_id(self, transfer_id: int) -> Dict[str, Any]:
"""
get users by id
:param transfer_id:
:return: transfer list of dict
"""
self.logger.info("Get transfer record by id %s", transfer_id)
try:
transfer = TransferModel.get_transfer_by_id(transfer_id)
if not transfer:
raise SQLCustomError(
description="No data for requested transfer id: {}".format(
transfer_id))
return transfer.as_dict()
except SQLAlchemyError:
self.logger.error(
"Get transfer record by id fail. id %s. error %s", transfer_id,
traceback.format_exc())
raise SQLCustomError(description="GET transfer by ID SQL ERROR")