public bool DeleteLecturer(long lecturerId) { try { return(lecturerId > 0 && _lecturerRepository.DeleteLecturer(lecturerId)); } catch (Exception e) { return(false); } }
public async Task <IdentityResult> DeleteAsync(ApplicationUser user, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (var connection = new SqlConnection(_connectionString)) { await connection.OpenAsync(cancellationToken); await connection.ExecuteAsync($"DELETE FROM [ApplicationUser] WHERE [Id] = @{nameof(ApplicationUser.Id)}", user); } if (user.userType is Lecturer) { lecturerRepository.DeleteLecturer(user.userTypeId); } else if (user.userType is Student) { studentRepository.DeleteAccount(user.userTypeId); } return(IdentityResult.Success); }
public void DeleteLecturer(int lecturerID) { _lecturerRepository.DeleteLecturer(lecturerID); _lecturerRepository.Save(); }
public ActionResult DeleteLecturer(int lecturerId) { /* * Deleting a lecturer is quite an impactful action to the system's data because a lecturer record * has its primary key (student_id) as a foriegn key in other entities, thus prompting the associated * records in those entities to also be deleted. * * The worst case scenario for this, is when the deletion of a lecturer affects n number of entities (prompting their records to be removed also), where n is the maximum number of entities that * can be affected. * * This scenario occurs when the FYP time-period has commenced and the lecturer, being in supervision * of FYP group(s) and also, happened to propose "lecturer-intiated" projects and made announcements * (also attaching file resources to at least one of the announcement(s)) before (the commenement of * the FYP time-period), has decided to leave SP. In this worst case scenario, n turns out to be 4 * (The four affected entities are namely; Announcement, File_Resource, Group, * Industry_Lecturer_Project). * * Superificially, it might seem OK to have those record(s) in (all) the associated tables, deleted. * However practically, it would make no sense, to have a group (with students in it deleted) merely * because its supervisor has left SP. * * Hence, in practicality n would be modified as; n = 4 - 1 = 3, where the entity, "exempted" from * deletion is; Group. * * Additionally, it should be noted that n can be further reduced to; n = 3 - 2 = 1, where the * additional two entities, which should also be exempted deletion (alike the above-mentioned * Group entity) are; Announcement and File_Resource. However due to technical database * constraint, those two entities would not be removed from deletion. Thus, n is still; 3. * * Also, like Group, the records in the Industry_Lecturer_Project entity should not be deleted. Thus * n = 3 - 1 = 2; * * Hence as dicussed above, in the worst case scenario, only at most n entities can be affected, where * n is revealed to be 2. The affected entities are thus Announcement and File_Resource. * * Thus, with the above discussion, the code below deletes associated records from the the Announcement * and File_Resource entity. */ // Variable declaration and initialization. int numberOfRowsAffected = 0; IAnnouncementRepository announcementRepository = new AnnouncementRepository(); IFileResourceRepository fileResourceRepository = new FileResourceRepository(); IProjectRepository projectRepository = new ProjectRepository(); IGroupRepository groupRepository = new GroupRepository(); IEnumerable <Announcement> associatedAnnouncements = null; IEnumerable <object> associatedGroups = null; IEnumerable <dynamic> associatedIndustryLecturerProjects = null; try { associatedAnnouncements = announcementRepository.GetAnnouncementsByLecturerId(lecturerId); // Deleting records from the File_Resource entity. foreach (Announcement announcement in associatedAnnouncements) { fileResourceRepository.DeleteFileResourcesForAnnouncement(announcement.announcement_id); } // Deleting Announcement's records. announcementRepository.DeleteAnnouncementsForLecturer(lecturerId); associatedGroups = groupRepository.GetGroupsByLecturerId(lecturerId); // Disassociating any group records which are currently associated to the (to be) deleted lecturer record, by setting the group_role field in the Group entity to NULL. foreach (object group in associatedGroups) { int groupId = int.Parse(group.GetType().GetProperty("groupId").GetValue(group, null).ToString()); groupRepository.AssignSupervisor(null, groupId); } associatedIndustryLecturerProjects = projectRepository.GetIndustryLecturerProjectsByLecturerId(lecturerId); // Disassociating any project records which are currently associated to the (to be) deleted lecturer record, by setting the lecturer_id field in the Lecturer entity to NULL. foreach (dynamic project in associatedIndustryLecturerProjects) { projectRepository.SetLecturerId(project.project_id, null); } // Finally, once all records are properly settled, as from above, delete the lecturer (from the Lecturer entity). numberOfRowsAffected = lecturerRepository.DeleteLecturer(lecturerId); return(Json(new { rowsAffected = numberOfRowsAffected })); } catch (Exception e) { return(Json(new { rowsAffected = numberOfRowsAffected, error = e.Message })); } }