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_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_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 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 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 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 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 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 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 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_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 reset_password(self, data: Dict) -> bool:
"""
reset password by full admin
"""
if not self.input_validate.validate_json(data, password_reset_schema):
self.logger.error("Reset password validation fail")
raise ValidateFail("Reset password validation fail")
user = self.get_user_model_by_id(data.get("user_id"))
return self.change_password_by_id(user.id, data.get("password"))
def create_school(self, data: Dict) -> bool:
"""
create school records
: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 validation fail")
try:
return SchoolModel.create_school(SchoolModel(**data))
except SQLAlchemyError as error:
self.logger.error("School create fail. error %s", error)
raise SQLCustomError("School create fail")
def create_attendance(self, data: Dict) -> bool:
"""
create attendance records
: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 validation fail")
try:
return AttendanceModel.create_attendance(AttendanceModel(**data))
except SQLAlchemyError as error:
self.logger.error("Attendance create fail. error %s, format: %s ",
error, traceback.format_exc())
raise SQLCustomError("Attendance create fail")
def create_extra_fund(self, data: Dict[str, str]) -> bool:
"""
create new extra fund
:param data: data dict includes extra fund_id, mmk_amount, transfer_id
:return: True if creation success else False
"""
if not data:
raise RequestDataEmpty("Extra funds data is empty")
if not self.input_validate.validate_json(data, extra_funds_schema):
self.logger.error("All extra field input must be required.")
raise ValidateFail("Extra validation fail")
try:
return ExtraFundsModel.create_extra_fund(
ExtraFundsModel(mmk_amount=int(data["mmk_amount"]),
transfer_id=int(data["transfer_id"])))
except SQLAlchemyError:
self.logger.error("Extra funds create fail. error %s",
traceback.format_exc())
raise SQLCustomError("Extra funds create fail")
def change_password(self, user_id: int, data: Dict[str, str]) -> bool:
"""
change password by user
:params user_id
:params data
"""
if not self.input_validate.validate_json(data, password_change_schema):
self.logger.error("Change password validation fail")
raise ValidateFail("Change password validation fail")
current_pwd = data.get("current_password")
new_pwd = data.get("new_password")
new_confirm_pwd = data.get("new_confirm_password")
user = self.get_user_model_by_id(user_id)
if not self.check_password(current_pwd, user):
raise ThingahaCustomError("Current password is incorrect.")
if new_pwd == new_confirm_pwd:
return self.change_password_by_id(user_id, new_pwd)
self.logger.error("Password and confirm password are different")
raise ThingahaCustomError(
"Password and confirm password are different")
def create_attendance(self, data: Dict) -> bool:
"""
create attendance records
: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 validation fail")
try:
return AttendanceModel.create_attendance(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("Attendance create fail. error %s", error)
raise SQLCustomError("Attendance create fail")
def create_transfer(self, data: Dict[str, str]) -> bool:
"""
create new transfer
:param data: data dict includes year, month, jpy amount, mmk amount
:return: True if creation success else False
"""
if not data:
raise RequestDataEmpty("Transfer data is empty")
if not self.input_validate.validate_json(data, transfer_schema):
self.logger.error("All scheme field input must be required.")
raise ValidateFail("Transfer validation fail")
try:
return TransferModel.create_transfer(
TransferModel(year=int(data["year"]),
month=data["month"],
total_jpy=int(data["total_jpy"]),
total_mmk=int(data["total_mmk"])))
except SQLAlchemyError:
self.logger.error("Transfer create fail. error %s",
traceback.format_exc())
raise SQLCustomError("Transfer create fail")
