vincent.p.mercier/Kalulu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add GP_remediation synchronization

Browse Source 
Debug & cleaning
This commit is contained in:
Adrien Ufferte
2025-06-17 09:37:23 +02:00
parent dda21764d6
commit f86c288687
3 changed files with 123 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sources/utils/autoloads/user_data_manager.gd
+4 -2
View File
@@ -24,7 +24,7 @@ var _student_remediation: UserRemediation
var _student_difficulty: UserDifficulty
var _student_speeches: UserSpeeches
var user_database_synchronizer: UserDataBaseSynchronizer
var user_database_synchronizer: UserDatabaseSynchronizer
var synchronization_timer: int = 0
var synchronization_timer_running: bool = false
var synchronization_time_limit: int = 300000 # 5 minutes in milliseconds
@@ -36,10 +36,12 @@ func _ready() -> void:
if get_device_settings().teacher:
_load_teacher_settings()
user_database_synchronizer = UserDataBaseSynchronizer.new()
user_database_synchronizer = UserDatabaseSynchronizer.new()
func _process(_delta: float) -> void:
if Engine.is_editor_hint():
return # Do nothing in editor mode
if synchronization_timer_running:
now = Time.get_ticks_msec()
real_delta = now - last_time
sources/utils/autoloads/user_database_synchronizer.gd
+112 -61
View File
@@ -1,5 +1,5 @@
extends Node
class_name UserDataBaseSynchronizer
class_name UserDatabaseSynchronizer
var synchronizing: bool = false
@@ -50,7 +50,7 @@ func _pull_timestamps() -> Dictionary:
set_loading_bar_text("SYNCHRONIZATION_ASK_SERVER_TIMESTAMP")
var res: Dictionary = await (ServerManager as ServerManagerClass).pull_timestamps()
if not res.success:
Logger.trace("UserDataBaseSynchronizer: Cannot get all timestamps from server. Canceling synchronization.")
Logger.trace("UserDatabaseSynchronizer: Cannot get all timestamps from server. Canceling synchronization.")
set_loading_bar_text("SYNCHRONIZATION_ERROR_NO_SERVER")
stop_sync()
return {}
@@ -61,13 +61,13 @@ func _pull_timestamps() -> Dictionary:
func _determine_user_update(response_body: Dictionary) -> UpdateNeeded:
set_loading_bar_text("SYNCHRONIZATION_COMPARE_SERVER_TIMESTAMP")
if not response_body.has("user"):
Logger.trace("UserDataBaseSynchronizer: Cannot get user from body. Canceling synchronization.")
Logger.trace("UserDatabaseSynchronizer: Cannot get user from body. Canceling synchronization.")
set_loading_bar_text("SYNCHRONIZATION_ERROR_NO_BODY_FROM_SERVER")
stop_sync()
return UpdateNeeded.Nothing
var user: Dictionary = response_body.user
if not user.has("last_modified"):
Logger.trace("UserDataBaseSynchronizer: Cannot get last_modified from user. Canceling synchronization.")
Logger.trace("UserDatabaseSynchronizer: Cannot get last_modified from user. Canceling synchronization.")
set_loading_bar_text("SYNCHRONIZATION_ERROR")
stop_sync()
return UpdateNeeded.Nothing
@@ -78,7 +78,7 @@ func _determine_user_update(response_body: Dictionary) -> UpdateNeeded:
local_unix_time_user = Time.get_unix_time_from_datetime_string(local_user_string_time)
var need_update_user: UpdateNeeded = UpdateNeeded.Nothing
if local_unix_time_user == server_unix_time_user:
Logger.trace("UserDataBaseSynchronizer: User data timestamp is the same in local and on server. No synchronization necessary")
Logger.trace("UserDatabaseSynchronizer: User data timestamp is the same in local and on server. No synchronization necessary")
elif local_unix_time_user > server_unix_time_user:
need_update_user = UpdateNeeded.FromLocal
else:
@@ -87,9 +87,9 @@ func _determine_user_update(response_body: Dictionary) -> UpdateNeeded:
func _determine_students_update(response_body: Dictionary, need_update_user: UpdateNeeded) -> Dictionary:
var need_update_students: Dictionary[int, UpdateNeeded]
var need_update_students: Dictionary[int, Dictionary] = {}
if not response_body.has("students"):
Logger.trace("UserDataBaseSynchronizer: Cannot get last_modified from user. Canceling synchronization.")
Logger.trace("UserDatabaseSynchronizer: Cannot get last_modified from user. Canceling synchronization.")
set_loading_bar_text("SYNCHRONIZATION_ERROR")
stop_sync()
return {}
@@ -104,84 +104,135 @@ func _determine_students_update(response_body: Dictionary, need_update_user: Upd
if student_dic.has("updated_at"):
server_student_unix_time = Time.get_unix_time_from_datetime_string(student_dic.updated_at as String)
else:
Logger.warn("UserDataBaseSynchronizer: Student %d received from server has no timestamp" % code_to_check)
Logger.warn("UserDatabaseSynchronizer: Student %d received from server has no timestamp" % code_to_check)
var server_student_remediation_unix_time: int = -1
if student_dic.has("gp_remediation_last_modified"):
server_student_remediation_unix_time = Time.get_unix_time_from_datetime_string(student_dic.gp_remediation_last_modified as String)
var found: bool = false
for device: int in UserDataManager.teacher_settings.students.keys():
var students_in_device: Array[StudentData] = UserDataManager.teacher_settings.students[device]
for student_data: StudentData in students_in_device:
if student_data.code == code_to_check:
found = true
# Synchronize student data
var local_student_unix_time: int = Time.get_unix_time_from_datetime_string(student_data.last_modified)
if local_student_unix_time == server_student_unix_time:
Logger.trace("UserDataBaseSynchronizer: Student %d data timestamp is the same in local and on server. No synchronization necessary" % code_to_check)
need_update_students[code_to_check] = UpdateNeeded.Nothing
Logger.trace("UserDatabaseSynchronizer: Student %d data timestamp is the same in local and on server. No synchronization necessary" % code_to_check)
need_update_students[code_to_check] = {"data": UpdateNeeded.Nothing}
elif local_student_unix_time > server_student_unix_time:
need_update_students[code_to_check] = UpdateNeeded.FromLocal
need_update_students[code_to_check] = {"data": UpdateNeeded.FromLocal}
else:
need_update_students[code_to_check] = UpdateNeeded.FromServer
found = true
need_update_students[code_to_check] = {"data": UpdateNeeded.FromServer}
# Synchronize student gp remediation
var student_gp_remediation: UserRemediation = UserDataManager.get_student_remediation_data(code_to_check)
if student_gp_remediation != null:
var local_student_gp_remediation_unix_time: int = Time.get_unix_time_from_datetime_string(student_gp_remediation.last_modified)
#server_student_remediation_unix_time
if local_student_gp_remediation_unix_time == server_student_remediation_unix_time:
Logger.trace("UserDatabaseSynchronizer: Student %d GP remediation data timestamp is the same in local and on server. No synchronization necessary" % code_to_check)
need_update_students[code_to_check] = {"remediation_gp": UpdateNeeded.Nothing}
elif local_student_gp_remediation_unix_time > server_student_remediation_unix_time:
need_update_students[code_to_check] = {"remediation_gp": UpdateNeeded.FromLocal}
else:
need_update_students[code_to_check] = {"remediation_gp": UpdateNeeded.FromServer}
break
if found:
break
if not found:
if need_update_user == UpdateNeeded.FromServer:
need_update_students[code_to_check] = UpdateNeeded.FromServer
need_update_students[code_to_check]["data"] = UpdateNeeded.FromServer
elif need_update_user == UpdateNeeded.FromLocal:
need_update_students[code_to_check] = UpdateNeeded.DeleteServer
need_update_students[code_to_check]["data"] = UpdateNeeded.DeleteServer
else:
Logger.warn("UserDataBaseSynchronizer: Student %d not found in local, but user doesn't need to be updated...this is theoretically not possible" % code_to_check)
Logger.warn("UserDatabaseSynchronizer: Student %d not found in local, but user doesn't need to be updated...this is theoretically not possible" % code_to_check)
for device: int in UserDataManager.teacher_settings.students.keys():
var students_in_device: Array[StudentData] = UserDataManager.teacher_settings.students[device]
for student_data: StudentData in students_in_device:
if not need_update_students.has(student_data.code):
if need_update_user == UpdateNeeded.FromServer:
need_update_students[student_data.code] = UpdateNeeded.DeleteLocal
need_update_students[student_data.code]["data"] = UpdateNeeded.DeleteLocal
elif need_update_user == UpdateNeeded.FromLocal:
need_update_students[student_data.code] = UpdateNeeded.FromLocal
need_update_students[student_data.code]["data"] = UpdateNeeded.FromLocal
else:
Logger.warn("UserDataBaseSynchronizer: Student %d not found in server, but user doesn't need to be updated...this is theoretically not possible" % student_data.code)
Logger.warn("UserDatabaseSynchronizer: Student %d not found in server, but user doesn't need to be updated...this is theoretically not possible" % student_data.code)
return need_update_students
func _build_message_to_server(need_update_user: UpdateNeeded, need_update_students: Dictionary) -> Dictionary:
func _build_message_to_server(need_update_user: UpdateNeeded, need_update_students: Dictionary[int, Dictionary]) -> Dictionary:
var message_to_server: Dictionary = {}
# Gérer l'utilisateur
if need_update_user == UpdateNeeded.FromLocal:
message_to_server["user"] = {
"account_type": UserDataManager.teacher_settings.account_type,
"education_method": UserDataManager.teacher_settings.education_method,
"last_modified": UserDataManager.teacher_settings.last_modified
}
message_to_server["user"] = {
"account_type": UserDataManager.teacher_settings.account_type,
"education_method": UserDataManager.teacher_settings.education_method,
"last_modified": UserDataManager.teacher_settings.last_modified
}
elif need_update_user == UpdateNeeded.FromServer:
message_to_server["user"] = {"need_update": true}
message_to_server["students"] = {}
for student_code_to_update: int in need_update_students.keys():
if need_update_students[student_code_to_update] == UpdateNeeded.Nothing:
continue
elif need_update_students[student_code_to_update] == UpdateNeeded.FromLocal:
var student_device:int = UserDataManager.teacher_settings.get_student_device(student_code_to_update)
if student_device == -1:
Logger.error("UserDataBaseSynchronizer: Student code %s has no device ID" % student_code_to_update)
for student_code: int in need_update_students.keys():
var student_entry: Dictionary = need_update_students[student_code]
var student_block: Dictionary = {}
# Traitement de l'étudiant lui-même
if student_entry.has("data"):
var student_update: UpdateNeeded = student_entry["data"]
if student_update == UpdateNeeded.DeleteLocal:
UserDataManager.delete_student(student_code)
continue
var student_data: StudentData = UserDataManager.teacher_settings.get_student_with_code(student_code_to_update)
if not student_data:
Logger.warn("UserDataBaseSynchronizer: Cannot find student with code %d" % student_code_to_update)
continue
message_to_server["students"][student_code_to_update] = {
"device_id": student_device,
"name": student_data.name,
"age": student_data.age,
"updated_at": student_data.last_modified,
}
elif need_update_students[student_code_to_update] == UpdateNeeded.FromServer:
message_to_server["students"][student_code_to_update] = {"need_update": true}
elif need_update_students[student_code_to_update] == UpdateNeeded.DeleteLocal:
UserDataManager.delete_student(student_code_to_update)
elif need_update_students[student_code_to_update] == UpdateNeeded.DeleteServer:
message_to_server["students"][student_code_to_update] = {"delete": true}
else:
Logger.warn("UserDataBaseSynchronizer: Update needed enum not recognized: %s" % str(need_update_students[student_code_to_update]))
if (message_to_server["students"] as Dictionary).keys().size() == 0:
elif student_update == UpdateNeeded.DeleteServer:
student_block["delete"] = true
elif student_update == UpdateNeeded.FromLocal:
var device_id: int = UserDataManager.teacher_settings.get_student_device(student_code)
if device_id == -1:
Logger.error("UserDatabaseSynchronizer: Student code %s has no device ID" % student_code)
continue
var student_data: StudentData = UserDataManager.teacher_settings.get_student_with_code(student_code)
if not student_data:
Logger.warn("UserDatabaseSynchronizer: Cannot find student with code %d" % student_code)
continue
student_block.merge({
"device_id": device_id,
"name": student_data.name,
"age": student_data.age,
"updated_at": student_data.last_modified
})
elif student_update == UpdateNeeded.FromServer:
student_block["need_update"] = true
# Traitement de "remediation_gp"
if student_entry.has("remediation_gp"):
var gp_remediation_block: Dictionary = {}
if student_entry.remediation_gp == UpdateNeeded.FromLocal:
var student_remediation: UserRemediation = UserDataManager.get_student_remediation_data(student_code)
var tuple_list: Array = []
for key: int in student_remediation.gps_scores.keys():
tuple_list.append([key, student_remediation.gps_scores[key]])
gp_remediation_block = {"score_remediation": tuple_list, "updated_at": student_remediation.last_modified}
elif student_entry.remediation_gp == UpdateNeeded.FromServer:
gp_remediation_block = {"need_update": true}
elif student_entry.remediation_gp == UpdateNeeded.DeleteServer:
gp_remediation_block = {"delete": true}
if gp_remediation_block.size() > 0:
student_block["remediation_gp"] = gp_remediation_block
if student_block.size() > 0:
message_to_server["students"][student_code] = student_block
if (message_to_server["students"] as Dictionary).is_empty():
message_to_server.erase("students")
return message_to_server
@@ -189,11 +240,11 @@ func _send_instructions(message_to_server: Dictionary) -> Dictionary:
await set_loading_bar_progression(60.0)
set_loading_bar_text("SYNCHRONIZATION_SEND_SERVER_INSTRUCTIONS")
if message_to_server.keys().size() == 0:
Logger.trace("UserDataBaseSynchronizer: No instruction to send to server")
Logger.trace("UserDatabaseSynchronizer: No instruction to send to server")
return {}
var res_get_server_instructions: Dictionary = await (ServerManager as ServerManagerClass).send_server_synchronization_instructions(message_to_server)
if not res_get_server_instructions.success:
Logger.trace("UserDataBaseSynchronizer: Cannot send instructions to server. Canceling synchronization.")
Logger.trace("UserDatabaseSynchronizer: Cannot send instructions to server. Canceling synchronization.")
set_loading_bar_text("SYNCHRONIZATION_ERROR_NO_SERVER")
stop_sync()
return {}
@@ -205,21 +256,21 @@ func _send_instructions(message_to_server: Dictionary) -> Dictionary:
func _apply_server_response(response_body: Dictionary) -> void:
if response_body.has("user"):
var response_user: Dictionary = response_body.user
Logger.trace("UserDataBaseSynchronizer: Updating user")
Logger.trace("UserDatabaseSynchronizer: Updating user")
if not response_user.has("account_type"):
Logger.warn("UserDataBaseSynchronizer: While updating user, no account_type found")
Logger.warn("UserDatabaseSynchronizer: While updating user, no account_type found")
else:
UserDataManager.teacher_settings.account_type = response_user.account_type
if not response_user.has("education_method"):
Logger.warn("UserDataBaseSynchronizer: While updating user, no education_method found")
Logger.warn("UserDatabaseSynchronizer: While updating user, no education_method found")
else:
UserDataManager.teacher_settings.education_method = response_user.education_method
if not response_user.has("last_modified"):
Logger.warn("UserDataBaseSynchronizer: While updating user, no last_modified found")
Logger.warn("UserDatabaseSynchronizer: While updating user, no last_modified found")
else:
UserDataManager.teacher_settings.last_modified = response_user.last_modified
if response_body.has("students"):
Logger.trace("UserDataBaseSynchronizer: Updating students")
Logger.trace("UserDatabaseSynchronizer: Updating students")
var response_students: Dictionary = response_body.students
for response_student_code: String in response_students.keys():
var response_student_data: Dictionary = response_students[response_student_code]
@@ -227,9 +278,9 @@ func _apply_server_response(response_body: Dictionary) -> void:
func synchronize() -> void:
Logger.trace("UserDataBaseSynchronizer: Start synchronizing user data.")
Logger.trace("UserDatabaseSynchronizer: Start synchronizing user data.")
if synchronizing:
Logger.trace("UserDataBaseSynchronizer: User synchronization already started, cancel double-call.")
Logger.trace("UserDatabaseSynchronizer: User synchronization already started, cancel double-call.")
return
await start_sync()
@@ -243,7 +294,7 @@ func synchronize() -> void:
var need_update_user: UpdateNeeded = _determine_user_update(response_body)
if not synchronizing:
return
var need_update_students: Dictionary[int, UpdateNeeded] = _determine_students_update(response_body, need_update_user)
var need_update_students: Dictionary[int, Dictionary] = _determine_students_update(response_body, need_update_user)
if not synchronizing:
return
await set_loading_bar_progression(40.0)