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_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 delete(self, email=None):
student = StudentModel.get_by_email(email)
if student:
record = StudentModel.delete_student(student)
return {"Result": record}, 200
return {
"Result": "record not exists for {email} id".format(email=email)
}, 404
def post(self):
data = StudentRegister.parser.parse_args()
if StudentModel.find_by_email(data['email']):
return {"message": "User already registered"}, 400
student = StudentModel(**data)
student.save_to_db()
return {"message": "User created successfully"}, 201
def delete(self, id):
student = Student.find(id)
if student is None:
return {'code': 400, 'message': 'School data not found'}, 400
Student.delete(id)
return {
'code': 200,
'message': 'Student data successfully deleted'
}, 200
def post(self, prn):
data = StudentResource.parser.parse_args()
student = StudentModel.find_by_prn(prn)
if student:
return {"message": "Already Exists"}
student = StudentModel(data['prn'], data['name'], data['mobile'],
data['email'], data['department'],
data['classid'])
student.insert_in_db()
return {"message": "Insert Success"}
def put(self, email=None):
student = StudentModel.get_by_email(email)
if not student:
return {
"Result":
"record not exists for {email} id".format(email=email)
}, 404
data = update_parser.parse_args()
record = StudentModel.update_student(student, data)
return {"Result": record}, 200
def get(self, email=None):
if email:
student = StudentModel.get(email)
if student:
return {"Result": student}, 200
return {
"Result":
"record not exists for {email} id".format(email=email)
}, 404
students = StudentModel.get_all()
return {"Result": students}, 200
def post(self):
data = StudentsResource.parser.parse_args()
student = Student(_id=None,
name=data['name'],
school_id=data['school_id'])
student.save()
return {
'code': 201,
'message': 'Student data created successfully'
}, 201
def post(self):
data = parser.parse_args()
try:
student = StudentModel.get(data.get('email'))
if student:
return {
"Result":
"{email} email id is already exists".format(
email=data.get('email'))
}, 409
record = StudentModel.save_to_db(data)
return {'Result': record}, 201
except Exception as error:
return {'Result': 'Error while saving record'}, 400
def put(self):
claims = get_jwt_claims()
data = _student_parser.parse_args()
for key in data.keys():
if str(data[key]).lower() in ('none', 'null', ''):
data[key] = None
dt = datetime.now().strftime("%Y-%m-%d, %H:%M:%S")
data["modified_date"] = dt
data["modified_by"] = claims["email"]
student_id = data.get("student_id")
student_name = data.get("student_name")
student_aadhar = data.get("aadhar")
if student_id:
student = StudentModel.find_by_student_id(student_id)
elif student_aadhar:
student = StudentModel.find_by_student_aadhar(student_aadhar)
elif student_name:
student = StudentModel.find_by_student_name(student_name)
else:
return {"message": "Missing student key fields"}, 404
try:
if student:
student.set_attribute(data)
else:
student = StudentModel(**data)
student.save_to_db()
return student.json()
except Exception as ex:
return {"message": f"Error updating student data. {repr(ex)}"}, 403
def set_attribute(self, payload):
cols = [
'attempt_id', 'student_id', 'subject_id', 'category_id',
'skill_id', 'period_id', 'year', 'month', 'day', 'session',
'score', 'full_score', 'grade', 'creation_date', 'modified_date',
'modified_by'
]
for col in cols:
if col in payload.keys():
setattr(self, col, payload[col])
if 'subject_name' in payload.keys():
subjects = SubjectModel.find_by_subject_name(
payload["subject_name"])
if subjects:
self.subject_id = subjects[0].id
if 'category_name' in payload.keys():
data = {'category_name': payload["category_name"]}
assessment_categories = AssessmentCategoryModel.find_assessment_category_by_any(
**data)
if assessment_categories:
self.category_id = assessment_categories[0].id
if 'skill_name' in payload.keys():
# data = {'skill_name': payload["skill_name"]}
assessment_skill = AssessmentSkillModel.find_by_skill_name(
payload["skill_name"])
if assessment_skill:
self.skill_id = assessment_skill.id
if 'subject_name' in payload.keys():
data = {'category_name': payload["subject_name"]}
subject = StudentModel.find_by_student_name(
payload["subject_name"])
if subject:
self.subject_id = subject.id
def resolve_student(_, info, **kwargs):
# return "user"
id = kwargs.get("id", None)
user = None
if id:
user = StudentModel.find_by_id(id)
return user
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 post(self):
data = StudentRegister.parser.parse_args()
if StudentModel.find_by_name(data["name"]):
return {"Message": "Student Exits"}
else:
# StudentModel.insert_student(data["name"], data["password"])
return {"Message": "Student does not exists"}
def json(self):
student = StudentModel.find_by_student_id(self.student_id)
cluster = ClusterModel.find_by_cluster_id(student.cluster_id)
kalika_kendra = KalikaKendraModel.find_by_kalika_kendra_id(
student.kalika_kendra_id)
return {
'result_id':
self.id,
'attempt_id':
self.attempt_id,
'student_id':
self.student_id,
'student_name':
student.student_name if student else None,
'cluster_id':
cluster.id if cluster else None,
'cluster_name':
cluster.cluster_name if cluster else None,
'kalika_kendra_id':
kalika_kendra.id if kalika_kendra else None,
'kalika_kendra_name':
kalika_kendra.kalika_kendra_name if kalika_kendra else None,
'subject_id':
self.subject_id,
'subject_name':
SubjectModel.find_by_subject_id(self.subject_id).subject_name,
'assessment_category_id':
self.category_id,
'assessment_category_name':
AssessmentCategoryModel.find_by_category_id(
self.category_id).category_name,
'assessment_skill_id':
self.skill_id,
'assessment_skill_name':
AssessmentSkillModel.find_by_skill_id(self.skill_id).skill_name
if AssessmentSkillModel.find_by_skill_id(self.skill_id) else None,
'assessment_period_id':
self.period_id,
'assessment_year':
self.year,
'assessment_month':
self.month,
'assessment_day':
self.day,
'assessment_session':
self.session,
'assessment_score':
self.score,
'assessment_full_score':
self.full_score,
'assessment_grade':
self.grade,
'creation_date':
str(self.creation_date),
'modified_date':
str(self.modified_date),
'modified_by':
self.modified_by
}
def get(self):
data = request.args
print(data)
data = data.to_dict(flat=False)
claims = get_jwt_claims()
student_kalika_kendra_name = None
student_kalika_kendra_id = None
student_cluster_name = None
student_cluster_id = None
if not claims['is_admin']:
user_email = claims['email']
if claims['teacher_code']:
teacher = TeacherModel.find_by_teacher_code(
claims['teacher_code'])
student_kalika_kendra_id = teacher.kalika_kendra_id
print(student_kalika_kendra_id)
else:
return {
'message': 'User do not have permission. Contact admin.'
}, 401
student_id = data.get("student_id")
student_name = data.get("student_name")
student_aadhar = data.get("aadhar")
print(data)
if student_id:
student = StudentModel.find_by_student_id(student_id)
if student_aadhar:
student = StudentModel.find_by_student_aadhar(student_aadhar)
if student_name:
student = StudentModel.find_by_student_name(student_name)
if student:
print(student.kalika_kendra_id)
if claims['is_admin'] or (str(student.kalika_kendra_id).__eq__(
str(student_kalika_kendra_id))):
return student.json()
else:
return {
'message':
'User not authorized to view other Kalika Kendra data.'
}, 401
else:
return {"message": "Student not found"}, 404
def delete(self, identification_number: int):
student = StudentModel.find_by_name_surname(identification_number)
if student:
student.delete_from_db()
return {
"message": constants.STUDENT_DELETED.format(identification_number)
}
def delete(self, college_id, rollno):
data = Student.parser.parse_args()
clg = CollegeModel.find_by_id(college_id)
if clg.password == data['clg_password']:
student = StudentModel.find_by_rollno(college_id, rollno)
if student:
student.delete_from_db()
return {'message': 'Student deleted.'}
return {'message': 'Student not found.'}, 404
def delete(self, prn):
claims = get_jwt_claims()
if not claims['is_admin']:
return {"message": "Admin priviledge required"}, 401
student = StudentModel.find_by_prn(prn)
if student:
student.delete_from_db()
return {"message": "Delete success"}
return {"message": "Not found for delete"}
def get(self):
user_id = get_jwt_identity()
if user_id is None:
return {'code': 200, 'students': []}, 200
students = Student.get()
return {
'code': 200,
'students': list(student._json() for student in students)
}, 200
def delete(self):
claims = get_jwt_claims()
if not claims['is_admin']:
return {'message': 'Admin privilege required.'}, 401
data = _student_parser.parse_args()
student_id = data.get("student_id")
student_name = data.get("student_name")
student_aadhar = data.get("aadhar")
if student_id:
student = StudentModel.find_by_student_id(student_id)
elif student_aadhar:
student = StudentModel.find_by_student_aadhar(student_aadhar)
elif student_name:
student = StudentModel.find_by_student_name(student_name)
else:
return {"message": "Missing student key fields"}, 404
if student:
student.delete_from_db()
return {'message': 'Student deleted.'}
return {'message': 'Student not found.'}, 404
def put(self, id):
data = Student.parser.parse_args()
student = StudentModel.find_by_id(id)
if student is None:
student = StudentModel(id, **data)
else:
student.name = data["name"]
student.degree_id = data["degree_id"]
student.save_to_db()
return student.json(), 201
def put(self, prn):
data = StudentResource.parser.parse_args()
student = StudentModel.find_by_prn(prn)
if student:
student.name = data['name']
student.mobile = data['mobile']
student.email = data['email']
student.department = data['department']
student.classid = data['classid']
student.insert_in_db()
return {"message": "Update success"}
return {"message": "Not found for update"}
def delete_student_by_id(self, student_id: int) -> bool:
"""
delete student by id
:param student_id:
:return:
"""
try:
self.logger.info("Delete student info by student_id:{}".format(student_id))
return StudentModel.delete_student(student_id)
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="Delete student by ID SQL ERROR")
def post(self, college_id, rollno):
data = Student.parser.parse_args()
clg = CollegeModel.find_by_id(college_id)
if clg.password == data['clg_password']:
if StudentModel.find_by_rollno(college_id, rollno):
return {
'message':
"An student with rollno '{}' already exists.".format(
rollno)
}, 400
data = Student.parser.parse_args()
student = StudentModel(college_id, rollno, **data)
try:
student.save_to_db()
except:
return {
"message": "An error occurred inserting the student."
}, 500
return student.json(), 201
else:
return {"message": "Please enter the correct password!"}
def get_all_student_address(self, page: int = 1) -> (List[Dict], int):
"""
get all school address for get all address API
:params page integer
:return
"""
try:
self.logger.info("Get all student address list")
students_address = StudentModel.get_all_student_address(page)
return [address.address_type_dict(student) for address, student in students_address.items], students_address.total
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="GET student address SQL ERROR")
def get_students_by_address_ids(
address_ids: tuple) -> Dict[int, StudentModel]:
"""
get student info by address_ids
:param address_ids:
:return: student list of dict
"""
try:
students = StudentModel.get_student_by_address_ids(address_ids)
return {student.address_id: student for student in students}
except SQLAlchemyError:
raise SQLCustomError(
description="GET users by ids query SQL ERROR")
def put(self, name):
if StudentModel.find_by_name(name) is None:
return {"Message": "Student does not exists"}
data = DetailsRegister.parser.parse_args()
DetailsModel.update_details(
data["id"],
data["Password"],
data["Address"],
data["Phone"],
data["Score"],
data["Name"],
)
return {"Msg": "Student details updated"}
def get_all_students(self, page: int = 1) -> (List, Any):
"""
get all student
:params page
:return: student list of dict
"""
try:
self.logger.info("Get all students list")
students = StudentModel.get_all_students(page)
return self.__return_student_list(students.items), students.total
except SQLAlchemyError as error:
self.logger.error("Error: {}".format(error))
raise SQLCustomError(description="GET Student SQL ERROR")
