Examples with UserSchoolDataIdentifier fi.otavanopisto.muikku.model.users.UserSchoolDataIdentifier used on opensource projects

Example 36 with UserSchoolDataIdentifier

use of fi.otavanopisto.muikku.model.users.UserSchoolDataIdentifier in project muikku by otavanopisto.

the class WorkspaceSystemRESTService method synchronizeWorkspaceUsers.

@GET
@Path("/syncworkspaceusers/{ID}")
@RESTPermit(handling = Handling.INLINE)
public Response synchronizeWorkspaceUsers(@PathParam("ID") Long workspaceEntityId, @Context Request request) {
    // Admins only
    if (!sessionController.isSuperuser()) {
        return Response.status(Status.UNAUTHORIZED).build();
    }
    logger.info(String.format("Synchronizing users of workspace entity %d", workspaceEntityId));
    // Workspace
    WorkspaceEntity workspaceEntity = workspaceEntityController.findWorkspaceEntityById(workspaceEntityId);
    if (workspaceEntity == null) {
        return Response.status(Status.NOT_FOUND).build();
    }
    // Student role
    WorkspaceRoleEntity workspaceStudentRole = roleController.findWorkspaceRoleEntityById(getWorkspaceStudentRoleId());
    // Workspace students in Muikku
    List<WorkspaceUserEntity> muikkuWorkspaceStudents = workspaceUserEntityController.listWorkspaceUserEntitiesByRole(workspaceEntity, workspaceStudentRole);
    logger.info(String.format("Before synchronizing, Muikku course has %d active students", muikkuWorkspaceStudents.size()));
    // Course students in Pyramus
    List<WorkspaceUser> pyramusCourseStudents = workspaceController.listWorkspaceStudents(workspaceEntity);
    logger.info(String.format("Before synchronizing, Pyramus course has %d active students", pyramusCourseStudents.size()));
    // Loop through Pyramus students
    for (WorkspaceUser pyramusCourseStudent : pyramusCourseStudents) {
        String pyramusStudentId = pyramusCourseStudent.getUserIdentifier().getIdentifier();
        String pyramusCourseStudentId = pyramusCourseStudent.getIdentifier().getIdentifier();
        // Find Muikku student corresponding to Pyramus student
        String muikkuWorkspaceStudentId = null;
        WorkspaceUserEntity muikkuWorkspaceStudent = null;
        for (int i = 0; i < muikkuWorkspaceStudents.size(); i++) {
            muikkuWorkspaceStudentId = muikkuWorkspaceStudents.get(i).getIdentifier();
            if (StringUtils.equals(muikkuWorkspaceStudentId, pyramusCourseStudentId)) {
                muikkuWorkspaceStudent = muikkuWorkspaceStudents.get(i);
                muikkuWorkspaceStudents.remove(i);
                break;
            }
        }
        if (muikkuWorkspaceStudent == null) {
            // Restore an archived workspace student, if possible
            muikkuWorkspaceStudent = workspaceUserEntityController.findWorkspaceUserEntityByWorkspaceUserIdentifierAndArchived(pyramusCourseStudent.getIdentifier(), Boolean.TRUE);
            if (muikkuWorkspaceStudent != null) {
                workspaceUserEntityController.unarchiveWorkspaceUserEntity(muikkuWorkspaceStudent);
                logger.info(String.format("Unarchived workspace student %s", pyramusCourseStudentId));
                SchoolDataIdentifier muikkuStudentIdentifier = new SchoolDataIdentifier(muikkuWorkspaceStudent.getUserSchoolDataIdentifier().getIdentifier(), muikkuWorkspaceStudent.getUserSchoolDataIdentifier().getDataSource().getIdentifier());
                ensureCorrectWorkspaceStudent(muikkuWorkspaceStudent, muikkuStudentIdentifier, pyramusCourseStudent.getUserIdentifier());
            } else {
                // Workspace student with workspace student identifier still not found, even amongst archived workspace students
                UserSchoolDataIdentifier userSchoolDataIdentifier = userSchoolDataIdentifierController.findUserSchoolDataIdentifierBySchoolDataIdentifier(pyramusCourseStudent.getUserIdentifier());
                if (userSchoolDataIdentifier == null) {
                    logger.severe(String.format("Unable to fix missing workspace student: UserSchoolDataIdentifier for Pyramus student %s not found", pyramusStudentId));
                } else {
                    // Try to find workspace student with workspace + student combo
                    muikkuWorkspaceStudent = workspaceUserEntityController.findWorkspaceUserEntityByWorkspaceAndUserSchoolDataIdentifierIncludeArchived(workspaceEntity, userSchoolDataIdentifier);
                    if (muikkuWorkspaceStudent != null) {
                        // Found. Might be archived but definitely has the wrong workspace student identifier
                        if (muikkuWorkspaceStudent.getArchived()) {
                            workspaceUserEntityController.unarchiveWorkspaceUserEntity(muikkuWorkspaceStudent);
                        }
                        if (!muikkuWorkspaceStudent.getIdentifier().equals(pyramusCourseStudent.getIdentifier().getIdentifier())) {
                            workspaceUserEntityController.updateIdentifier(muikkuWorkspaceStudent, pyramusCourseStudent.getIdentifier().getIdentifier());
                        }
                    } else {
                        // Not found. Create a new workspace student
                        muikkuWorkspaceStudent = workspaceUserEntityController.createWorkspaceUserEntity(userSchoolDataIdentifier, workspaceEntity, pyramusCourseStudentId, workspaceStudentRole);
                        logger.info(String.format("Created workspace student %s", muikkuWorkspaceStudent.getIdentifier()));
                    }
                }
            }
        } else {
            // Workspace student found with workspace student identifier. We still need to ensure that the underlying student is the same as in Pyramus
            SchoolDataIdentifier muikkuStudentIdentifier = new SchoolDataIdentifier(muikkuWorkspaceStudent.getUserSchoolDataIdentifier().getIdentifier(), muikkuWorkspaceStudent.getUserSchoolDataIdentifier().getDataSource().getIdentifier());
            ensureCorrectWorkspaceStudent(muikkuWorkspaceStudent, muikkuStudentIdentifier, pyramusCourseStudent.getUserIdentifier());
        }
    }
    // The remaining Muikku students in muikkuWorkspaceStudents were not in Pyramus so archive them from Muikku
    if (!muikkuWorkspaceStudents.isEmpty()) {
        for (WorkspaceUserEntity muikkuWorkspaceStudent : muikkuWorkspaceStudents) {
            workspaceUserEntityController.archiveWorkspaceUserEntity(muikkuWorkspaceStudent);
        }
        logger.info(String.format("Archived %d Muikku workspace students that were not present in Pyramus", muikkuWorkspaceStudents.size()));
    }
    // Student count in Muikku after synchronizing, which should be the same as in Pyramus before synchronization
    muikkuWorkspaceStudents = workspaceUserEntityController.listWorkspaceUserEntitiesByRole(workspaceEntity, workspaceStudentRole);
    logger.info(String.format("After synchronizing, Muikku course has %d active students", pyramusCourseStudents.size()));
    // Course staff maintenance
    // Teacher role
    WorkspaceRoleEntity workspaceTeacherRole = roleController.findWorkspaceRoleEntityById(getWorkspaceTeacherRoleId());
    // Workspace teachers in Muikku
    List<WorkspaceUserEntity> muikkuWorkspaceTeachers = workspaceUserEntityController.listWorkspaceUserEntitiesByRole(workspaceEntity, workspaceTeacherRole);
    logger.info(String.format("Before synchronizing, Muikku course has %d active teachers", muikkuWorkspaceTeachers.size()));
    // Course teachers in Pyramus
    List<WorkspaceUser> pyramusCourseTeachers = workspaceController.listWorkspaceStaffMembers(workspaceEntity);
    logger.info(String.format("Before synchronizing, Pyramus course has %d active teachers", pyramusCourseTeachers.size()));
    for (WorkspaceUser pyramusCourseTeacher : pyramusCourseTeachers) {
        String pyramusCourseTeacherId = pyramusCourseTeacher.getIdentifier().getIdentifier();
        String pyramusTeacherId = pyramusCourseTeacher.getUserIdentifier().getIdentifier();
        WorkspaceUserEntity muikkuWorkspaceTeacher = null;
        for (int i = 0; i < muikkuWorkspaceTeachers.size(); i++) {
            String muikkuCourseTeacherId = muikkuWorkspaceTeachers.get(i).getIdentifier();
            if (muikkuCourseTeacherId.equals(pyramusCourseTeacherId)) {
                muikkuWorkspaceTeacher = muikkuWorkspaceTeachers.get(i);
                muikkuWorkspaceTeachers.remove(i);
                break;
            }
        }
        if (muikkuWorkspaceTeacher == null) {
            muikkuWorkspaceTeacher = workspaceUserEntityController.findWorkspaceUserEntityByWorkspaceUserIdentifierAndArchived(pyramusCourseTeacher.getIdentifier(), Boolean.TRUE);
            if (muikkuWorkspaceTeacher != null) {
                workspaceUserEntityController.unarchiveWorkspaceUserEntity(muikkuWorkspaceTeacher);
                logger.info(String.format("Unarchived workspace teacher %s", pyramusCourseTeacherId));
                if (!muikkuWorkspaceTeacher.getIdentifier().equals(pyramusCourseTeacher.getIdentifier().getIdentifier())) {
                    workspaceUserEntityController.updateIdentifier(muikkuWorkspaceTeacher, pyramusCourseTeacher.getIdentifier().getIdentifier());
                }
            } else {
                UserSchoolDataIdentifier userSchoolDataIdentifier = userSchoolDataIdentifierController.findUserSchoolDataIdentifierBySchoolDataIdentifier(pyramusCourseTeacher.getUserIdentifier());
                if (userSchoolDataIdentifier == null) {
                    logger.severe(String.format("Unable to fix missing workspace teacher: UserSchoolDataIdentifier for Pyramus teacher %s not found", pyramusTeacherId));
                } else {
                    muikkuWorkspaceTeacher = workspaceUserEntityController.findWorkspaceUserEntityByWorkspaceAndUserSchoolDataIdentifierIncludeArchived(workspaceEntity, userSchoolDataIdentifier);
                    if (muikkuWorkspaceTeacher != null) {
                        if (muikkuWorkspaceTeacher.getArchived()) {
                            workspaceUserEntityController.unarchiveWorkspaceUserEntity(muikkuWorkspaceTeacher);
                        }
                        if (!muikkuWorkspaceTeacher.getIdentifier().equals(pyramusCourseTeacher.getIdentifier().getIdentifier())) {
                            workspaceUserEntityController.updateIdentifier(muikkuWorkspaceTeacher, pyramusCourseTeacher.getIdentifier().getIdentifier());
                        }
                    } else {
                        muikkuWorkspaceTeacher = workspaceUserEntityController.createWorkspaceUserEntity(userSchoolDataIdentifier, workspaceEntity, pyramusCourseTeacherId, workspaceTeacherRole);
                        logger.info(String.format("Created workspace teacher %", muikkuWorkspaceTeacher.getIdentifier()));
                    }
                }
            }
        }
    }
    // The remaining Muikku teachers in muikkuWorkspaceTeachers were not in Pyramus so archive them from Muikku
    if (!muikkuWorkspaceTeachers.isEmpty()) {
        for (WorkspaceUserEntity muikkuWorkspaceTeacher : muikkuWorkspaceTeachers) {
            workspaceUserEntityController.archiveWorkspaceUserEntity(muikkuWorkspaceTeacher);
        }
        logger.info(String.format("Archived %d Muikku workspace teachers that were not present in Pyramus", muikkuWorkspaceTeachers.size()));
    }
    return null;
}

Example 37 with UserSchoolDataIdentifier

use of fi.otavanopisto.muikku.model.users.UserSchoolDataIdentifier in project muikku by otavanopisto.

the class AbstractAuthenticationStrategy method processLogin.

protected AuthenticationResult processLogin(AuthSource authSource, Map<String, String[]> requestParameters, String externalId, List<String> emails, String firstName, String lastName) {
    if ((emails == null) || (emails.isEmpty())) {
        return new AuthenticationResult(Status.NO_EMAIL);
    }
    Collection<UserEntity> emailUsers = userEntityController.listUserEntitiesByEmails(emails);
    if (emailUsers.size() > 1) {
        return new AuthenticationResult(Status.CONFLICT, ConflictReason.SEVERAL_USERS_BY_EMAILS);
    }
    UserEntity emailUser = emailUsers.size() == 1 ? emailUsers.iterator().next() : null;
    boolean newAccount = false;
    User activeUser = null;
    UserIdentification userIdentification = userIdentificationController.findUserIdentificationByAuthSourceAndExternalId(authSource, externalId);
    if (userIdentification != null) {
        // User has identified by this auth source before
        if (emailUser != null && !emailUser.getId().equals(userIdentification.getUser().getId())) {
            return new AuthenticationResult(Status.CONFLICT, ConflictReason.EMAIL_BELONGS_TO_ANOTHER_USER);
        }
    } else {
        // User has not used this auth source before
        if (emailUser != null) {
            // But has existing user in the system, so we attach the identification into the same user
            userIdentification = userIdentificationController.createUserIdentification(emailUser, authSource, externalId);
        } else {
            List<User> users = null;
            // If user can be found from datasources by emails, we just attach those users to new entity
            schoolDataBridgeSessionController.startSystemSession();
            try {
                users = userSchoolDataController.listUsersByEmails(emails);
            } finally {
                schoolDataBridgeSessionController.endSystemSession();
            }
            UserEntity userEntity = null;
            for (User user : users) {
                UserSchoolDataIdentifier userSchoolDataIdentifier = userSchoolDataIdentifierController.findUserSchoolDataIdentifierByDataSourceAndIdentifier(user.getSchoolDataSource(), user.getIdentifier());
                if (userSchoolDataIdentifier != null) {
                    if (userEntity == null) {
                        userEntity = userSchoolDataIdentifier.getUserEntity();
                    } else if (!userEntity.getId().equals(userSchoolDataIdentifier.getUserEntity().getId())) {
                        logger.severe(String.format("User %s.%s points to multiple UserEntity instances", user.getSchoolDataSource(), user.getIdentifier()));
                        return new AuthenticationResult(Status.CONFLICT, ConflictReason.SEVERAL_USERS_BY_EMAILS);
                    }
                }
            }
            if (userEntity == null) {
                logger.severe(String.format("Unable to resolve UserEntity for %s", StringUtils.join(emails, ',')));
                return new AuthenticationResult(Status.NO_EMAIL);
            }
            userIdentification = userIdentificationController.createUserIdentification(userEntity, authSource, externalId);
            newAccount = true;
        }
    }
    if (activeUser == null) {
        activeUser = userSchoolDataController.findActiveUser(userIdentification.getUser().getDefaultSchoolDataSource(), userIdentification.getUser().getDefaultIdentifier());
        if (activeUser == null) {
            activeUser = userSchoolDataController.listUsersByEmails(emails).get(0);
        }
    }
    if (activeUser == null) {
        logger.severe(String.format("Active user could not be found"));
        return new AuthenticationResult(AuthenticationResult.Status.ERROR);
    }
    return login(userIdentification, activeUser, newAccount);
}