public void testModifyExternalAssessment() throws Exception {
Assert.assertTrue(gradebookFrameworkService.isGradebookDefined(GRADEBOOK_UID));
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
EXT_ID_1,
null,
EXT_TITLE_1,
new Double(10),
new Date(),
"Samigo",
new Boolean(false));
gradebookExternalAssessmentService.updateExternalAssessment(
GRADEBOOK_UID, EXT_ID_1, null, EXT_TITLE_1, new Double(20), null, new Boolean(false));
// Find the assessment and ensure that it has been updated
Long gbId = gradebookManager.getGradebook(GRADEBOOK_UID).getId();
Assignment asn = null;
List assignments = gradebookManager.getAssignments(gbId);
for (Iterator iter = assignments.iterator(); iter.hasNext(); ) {
Assignment tmp = (Assignment) iter.next();
if (tmp.getExternalId() != null && tmp.getExternalId().equals(EXT_ID_1)) {
asn = tmp;
break;
}
}
Assert.assertEquals(asn.getPointsPossible(), new Double(20));
// Ensure that the total points possible in the gradebook reflects the updated assessment's
// points
Assert.assertTrue(gradebookManager.getTotalPoints(gbId) == 30);
}
/**
* If we came to the instructor view from the assign details page, we need to set the previous and
* next student info according to the order and filter on the assign details page
*
* @return
*/
private List getOrderedEnrolleesFromAssignDetailsPage() {
setSortColumn(getPreferencesBean().getAssignmentDetailsTableSortColumn());
setSortAscending(getPreferencesBean().isAssignmentDetailsTableSortAscending());
List assignGradeRecords = new ArrayList();
List enrollments = new ArrayList();
Long assignmentIdAsLong = getAssignmentIdAsLong();
if (assignmentIdAsLong != null) {
Assignment prevAssignment = getGradebookManager().getAssignment(assignmentIdAsLong);
Category category = prevAssignment.getCategory();
Long catId = null;
if (category != null) catId = category.getId();
Map enrollmentMap = getOrderedStudentIdEnrollmentMapForItem(catId);
if (isEnrollmentSort()) {
return new ArrayList(enrollmentMap.values());
}
List studentUids = new ArrayList(enrollmentMap.keySet());
if (getGradeEntryByPoints())
assignGradeRecords =
getGradebookManager().getAssignmentGradeRecords(prevAssignment, studentUids);
else if (getGradeEntryByPercent() || getGradeEntryByLetter())
assignGradeRecords =
getGradebookManager().getAssignmentGradeRecordsConverted(prevAssignment, studentUids);
// Need to sort and page based on a scores column.
List scoreSortedStudentUids = new ArrayList();
for (Iterator iter = assignGradeRecords.iterator(); iter.hasNext(); ) {
AbstractGradeRecord agr = (AbstractGradeRecord) iter.next();
scoreSortedStudentUids.add(agr.getStudentId());
}
// Put enrollments with no scores at the beginning of the final list.
studentUids.removeAll(scoreSortedStudentUids);
// Add all sorted enrollments with scores into the final list
studentUids.addAll(scoreSortedStudentUids);
studentUids = finalizeSortingAndPaging(studentUids);
if (studentUids != null) {
Iterator studentIter = studentUids.iterator();
while (studentIter.hasNext()) {
String studentId = (String) studentIter.next();
EnrollmentRecord enrollee = (EnrollmentRecord) enrollmentMap.get(studentId);
if (enrollee != null) enrollments.add(enrollee);
}
}
}
return enrollments;
}
/** @return The comma-separated list of css styles to use in displaying the rows */
public String getRowStyles() {
StringBuilder sb = new StringBuilder();
for (Iterator iter = gradebookItemList.iterator(); iter.hasNext(); ) {
Object gradebookItem = iter.next();
if (gradebookItem instanceof GradableObject) {
GradableObject go = (GradableObject) gradebookItem;
if (go.isCourseGrade()) {
sb.append("internal");
break;
} else {
Assignment asn = (Assignment) go;
if (asn.isExternallyMaintained()) {
sb.append("external,");
} else {
sb.append("internal,");
}
}
} else {
sb.append("internal,");
}
}
return sb.toString();
}
/**
* @see org.springframework.test.AbstractTransactionalSpringContextTests#onSetUpInTransaction()
*/
protected void onSetUpInTransaction() throws Exception {
super.onSetUpInTransaction();
gradebookFrameworkService.addGradebook(GRADEBOOK_UID, GRADEBOOK_UID);
Gradebook gradebook = gradebookManager.getGradebook(GRADEBOOK_UID);
// Set up a holder for enrollments, teaching assignments, and sections.
integrationSupport.createCourse(GRADEBOOK_UID, GRADEBOOK_UID, false, false, false);
List studentUidsList =
Arrays.asList(
new String[] {
"student1", "student2", "student3",
});
addUsersEnrollments(gradebook, studentUidsList);
// Add an internal assignment
Long gbId = gradebook.getId();
asn_1Id =
gradebookManager.createAssignment(
gbId, ASN_1, new Double(10), null, Boolean.FALSE, Boolean.FALSE, Boolean.FALSE);
// Add a score for the internal assignment
List assignments = gradebookManager.getAssignments(gbId);
Assignment asn = null;
for (Iterator iter = assignments.iterator(); iter.hasNext(); ) {
Assignment tmp = (Assignment) iter.next();
if (tmp.getName().equals(ASN_1)) {
asn = tmp;
break;
}
}
List gradeRecords = new ArrayList();
gradeRecords.add(new AssignmentGradeRecord(asn, "student1", new Double(10)));
gradebookManager.updateAssignmentGradeRecords(asn, gradeRecords);
}
@SuppressWarnings("unchecked")
private void ensureAssignmentsSorted(List assignments, Comparator comparator, boolean save) {
if (logger.isDebugEnabled()) {
logger.debug(
"ensureAssignmentsSorted: comparator="
+ comparator
+ ", save="
+ save
+ ", assignments= "
+ Arrays.toString(assignments.toArray()));
}
// remove any non-assignments first
List gradeables = new ArrayList();
for (Iterator iterator = assignments.iterator(); iterator.hasNext(); ) {
GradableObject go = (GradableObject) iterator.next();
if (!(go instanceof Assignment)) { // ! go.isAssignment()) {
gradeables.add(go);
iterator.remove();
}
}
Collections.sort(gradeables, GradableObject.nameComparator);
// put everything in the established sort order first (if needed)
if (comparator == null) {
comparator = GradableObject.dateComparator;
if (logger.isDebugEnabled()) {
logger.debug("ensureAssignmentsSorted: setting default comparator=" + comparator);
}
}
if (!NoChangeMarkerComparator.class.isAssignableFrom(comparator.getClass())) {
// only sort if this is not the no-sort marker
if (logger.isDebugEnabled()) {
logger.debug("ensureAssignmentsSorted: sorting with comparator=" + comparator);
}
Collections.sort(assignments, comparator);
} else {
if (logger.isDebugEnabled()) {
logger.debug(
"ensureAssignmentsSorted: no sort, using NoChangeMarkerComparator=" + comparator);
}
}
// always need to sort by category
Collections.sort(assignments, GradableObject.categoryComparator);
// now ensure the numbering is set and correct
int saveCount = 0;
int updateCount = 0;
for (int i = 0; i < assignments.size(); i++) {
Assignment assignment = (Assignment) assignments.get(i);
Integer curOrder = assignment.getSortOrder();
if (logger.isDebugEnabled()) {
logger.debug(
"ensureAssignmentsSorted: checking if current order ("
+ curOrder
+ ") matches correct order ("
+ i
+ ") for assignment: "
+ assignment);
}
if (curOrder == null || i != curOrder.intValue()) {
// no match so we need to update it (else it is already set correctly, only save if needed)
assignment.setSortOrder(i);
updateCount++;
if (logger.isDebugEnabled()) {
logger.debug(
"ensureAssignmentsSorted: setting sort order ("
+ i
+ ") for assignment: "
+ assignment);
}
if (save) {
getGradebookManager().updateAssignment(assignment);
saveCount++;
if (logger.isDebugEnabled()) {
logger.debug("ensureAssignmentsSorted: saving assignment: " + assignment);
}
}
}
}
// set the ordering up in the assignment with support for categories
Map<String, List<Assignment>> categoryAssignments =
new LinkedHashMap<String, List<Assignment>>();
for (Assignment assignment : (List<Assignment>) assignments) {
String category = "NULL";
if (assignment.getCategory() != null) {
category = assignment.getCategory().getName();
}
if (!categoryAssignments.containsKey(category)) {
categoryAssignments.put(category, new ArrayList<Assignment>());
}
categoryAssignments.get(category).add(assignment);
// assignment.assignSorting(assignments.size(), i);
}
for (Entry<String, List<Assignment>> entry : categoryAssignments.entrySet()) {
List<Assignment> l = entry.getValue();
for (int i = 0; i < l.size(); i++) {
Assignment assignment = l.get(i);
// assign the counter for ordering
assignment.assignSorting(l.size(), i);
if (logger.isDebugEnabled()) {
logger.debug("ensureAssignmentsSorted: ordered: " + i + " : " + assignment);
}
}
}
// add back in the gradeables to the end
for (Object gradeable : gradeables) {
assignments.add(gradeable);
}
if (logger.isDebugEnabled()) {
logger.debug(
"ensureAssignmentsSorted: sorted assignments (updated="
+ updateCount
+ ", saved="
+ saveCount
+ "): "
+ Arrays.toString(assignments.toArray()));
}
}
@SuppressWarnings("unchecked")
public void sortDown() {
Long assignmentId = getAssignmentIdFromParam();
if (logger.isDebugEnabled()) {
logger.debug("Sort: sorting down: " + assignmentId);
}
List<Assignment> assignments = getGradebookManager().getAssignments(getGradebookId());
if (assignments.size() > 1) {
ensureAssignmentsSorted(assignments, GradableObject.sortingComparator, true);
// now adjust the numbering
for (int i = 0; i < assignments.size(); i++) {
Assignment a1 = assignments.get(i);
if (a1.getId().equals(assignmentId)) {
if (i < (assignments.size() - 1)) {
Assignment a2 = assignments.get(i + 1);
// only swap items which are in the same category
if ((a1.getCategory() == null && a2.getCategory() == null)
|| (a1.getCategory().equals(a2.getCategory()))) {
// swap the ordering of this item and the item below it
Integer holder = a1.getSortOrder();
a1.setSortOrder(a2.getSortOrder());
a2.setSortOrder(holder);
logger.info(
"Sort: DOWN swapping: "
+ a1.getId()
+ " (to "
+ a1.getSortOrder()
+ " from "
+ holder
+ ") with "
+ a2.getId());
// save the new orders
getGradebookManager().updateAssignment(a1);
getGradebookManager().updateAssignment(a2);
} else {
logger.info(
"Sort: DOWN: unable to swap items ("
+ a1.getId()
+ ","
+ a2.getId()
+ ") in different categories");
}
}
break;
}
}
}
}
protected void init() {
gradebookItemList = new ArrayList();
courseGrade = new CourseGrade();
if (getCategoriesEnabled()) {
/* if categories are enabled, we need to display a table that includes
* categories, assignments, and the course grade.
*/
List categoryListWithCG =
getGradebookManager()
.getCategoriesWithStats(
getGradebookId(),
getAssignmentSortColumn(),
isAssignmentSortAscending(),
getCategorySortColumn(),
isCategorySortAscending());
List<Category> categoryList = new ArrayList<Category>();
// first, remove the CourseGrade from the Category list
for (Iterator catIter = categoryListWithCG.iterator(); catIter.hasNext(); ) {
Object catOrCourseGrade = catIter.next();
if (catOrCourseGrade instanceof Category) {
categoryList.add((Category) catOrCourseGrade);
} else if (catOrCourseGrade instanceof CourseGrade) {
courseGrade = (CourseGrade) catOrCourseGrade;
}
}
// then, we need to check for special grader permissions that may limit which categories may
// be viewed
if (!isUserAbleToGradeAll() && isUserHasGraderPermissions()) {
// SAK-19896, eduservice's can't share the same "Category" class, so just pass the ID's
List<Long> catIds = new ArrayList<Long>();
for (Category category : (List<Category>) categoryList) {
catIds.add(category.getId());
}
List<Long> viewableCats =
getGradebookPermissionService()
.getCategoriesForUser(getGradebookId(), getUserUid(), catIds);
List<Category> tmpCatList = new ArrayList<Category>();
for (Category category : (List<Category>) categoryList) {
if (viewableCats.contains(category.getId())) {
tmpCatList.add(category);
}
}
categoryList = tmpCatList;
}
if (categoryList != null && !categoryList.isEmpty()) {
Comparator catComparator = null;
if (Assignment.SORT_BY_MEAN.equals(getAssignmentSortColumn())) {
catComparator = Category.averageScoreComparator;
} else if (Category.SORT_BY_WEIGHT.equals(getAssignmentSortColumn())) {
catComparator = Category.weightComparator;
} else if (Category.SORT_BY_NAME.equals(getAssignmentSortColumn())) {
catComparator = Category.nameComparator;
}
if (catComparator != null) {
Collections.sort(categoryList, catComparator);
if (!isAssignmentSortAscending()) {
Collections.reverse(categoryList);
}
}
Iterator catIter = categoryList.iterator();
while (catIter.hasNext()) {
Category myCat = (Category) catIter.next();
gradebookItemList.add(myCat);
List assignmentList = myCat.getAssignmentList();
if (assignmentList != null && !assignmentList.isEmpty()) {
Iterator assignIter = assignmentList.iterator();
while (assignIter.hasNext()) {
Assignment assign = (Assignment) assignIter.next();
if (assign.isExternallyMaintained()) displayGradeEditorCol = true;
gradebookItemList.add(assign);
}
ensureAssignmentsSorted(assignmentList, GradableObject.sortingComparator, false);
}
}
}
if (!isUserAbleToGradeAll()
&& (isUserHasGraderPermissions()
&& !getGradebookPermissionService()
.getPermissionForUserForAllAssignment(getGradebookId(), getUserUid()))) {
// is not authorized to view the "Unassigned" Category
} else {
List unassignedList =
getGradebookManager()
.getAssignmentsWithNoCategoryWithStats(
getGradebookId(), getAssignmentSortColumn(), isAssignmentSortAscending());
if (unassignedList != null && !unassignedList.isEmpty()) {
Category unassignedCat = new Category();
unassignedCat.setGradebook(getGradebook());
unassignedCat.setAverageScore(new Double(0));
unassignedCat.setName(getLocalizedString("cat_unassigned"));
unassignedCat.setAssignmentList(unassignedList);
if (!getWeightingEnabled()) unassignedCat.calculateStatistics(unassignedList);
gradebookItemList.add(unassignedCat);
Iterator unassignedIter = unassignedList.iterator();
while (unassignedIter.hasNext()) {
Assignment assignWithNoCat = (Assignment) unassignedIter.next();
if (assignWithNoCat.isExternallyMaintained()) displayGradeEditorCol = true;
gradebookItemList.add(assignWithNoCat);
}
}
ensureAssignmentsSorted(unassignedList, GradableObject.sortingComparator, false);
}
} else {
// Get the list of assignments for this gradebook, sorted as defined in the overview page.
List goList =
getGradebookManager()
.getAssignmentsAndCourseGradeWithStats(
getGradebookId(), getAssignmentSortColumn(), isAssignmentSortAscending());
if (goList != null && !goList.isEmpty()) {
Iterator goIter = goList.iterator();
while (goIter.hasNext()) {
GradableObject go = (GradableObject) goIter.next();
if (go.isCourseGrade()) {
courseGrade = (CourseGrade) go;
} else {
Assignment assign = (Assignment) go;
if (assign.isExternallyMaintained()) displayGradeEditorCol = true;
gradebookItemList.add(assign);
}
}
ensureAssignmentsSorted(goList, GradableObject.sortingComparator, false);
}
}
// Set up navigation
ToolSession session = SessionManager.getCurrentToolSession();
session.setAttribute("breadcrumbPage", "overview");
session.removeAttribute("adding");
session.removeAttribute("editing");
session.removeAttribute("middle");
}
public void testCreateExternalAssessmentWithCategory() throws Exception {
String categoryName = "My favorite category";
Long gbId = gradebookManager.getGradebook(GRADEBOOK_UID).getId();
Long catId = gradebookManager.createCategory(gbId, categoryName, new Double(0), 0, 0, 0, false);
Assert.assertTrue(gradebookFrameworkService.isGradebookDefined(GRADEBOOK_UID));
// Make sure the service knows that the external id has not been defined
Assert.assertFalse(
gradebookExternalAssessmentService.isExternalAssignmentDefined(GRADEBOOK_UID, EXT_ID_1));
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
EXT_ID_1,
null,
EXT_TITLE_1,
new Double(10),
new Date(),
"Samigo",
new Boolean(false),
catId);
// Make sure the service knows that the external id has been defined
Assert.assertTrue(
gradebookExternalAssessmentService.isExternalAssignmentDefined(GRADEBOOK_UID, EXT_ID_1));
// let's retrieve the assignment and double check the category setting
// due to security in GradebookService, we need to retrieve all assign and then iterate through
// to find this one
List<Assignment> allAssigns = gradebookManager.getAssignments(gbId);
boolean assignFound = false;
for (Assignment assign : allAssigns) {
if (assign.isExternallyMaintained() && EXT_ID_1.equals(assign.getExternalId())) {
assignFound = true;
// double check the category
if (assign.getCategory() == null || !catId.equals(assign.getCategory().getId())) {
fail("Category was not saved via addExternalAssessment");
}
}
}
if (!assignFound) {
fail("Could not retrieve newly added external assignment");
}
// double check that leaving category null leaves category unassigned
String externalId2 = "external ID 2";
String externalTitle = "Another externally maintained one";
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
externalId2,
null,
externalTitle,
new Double(10),
new Date(),
"Samigo",
new Boolean(false),
null);
// Make sure the service knows that the external id has been defined
Assert.assertTrue(
gradebookExternalAssessmentService.isExternalAssignmentDefined(GRADEBOOK_UID, externalId2));
// let's retrieve the assignment and double check the category setting
// due to security in GradebookService, we need to retrieve all assign and then iterate through
// to find this one
allAssigns = gradebookManager.getAssignments(gbId);
assignFound = false;
for (Assignment assign : allAssigns) {
if (assign.isExternallyMaintained() && externalId2.equals(assign.getExternalId())) {
assignFound = true;
// double check the category
if (assign.getCategory() != null) {
fail("Category should be null for external assignment added via addExternalAssessment");
}
}
}
if (!assignFound) {
fail("Could not retrieve newly added external assignment without a category");
}
// Make sure that internal name conflicts are detected
try {
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
"A unique external id",
null,
ASN_1,
new Double(10),
new Date(),
"Samigo",
new Boolean(false),
catId);
fail();
} catch (ConflictingAssignmentNameException e) {
}
// Make sure that external name conflicts are detected
try {
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
"Another unique external id",
null,
EXT_TITLE_1,
new Double(10),
new Date(),
"Samigo",
new Boolean(false),
catId);
fail();
} catch (ConflictingAssignmentNameException e) {
}
// Make sure that external id conflicts are detected
try {
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
EXT_ID_1,
null,
"A unique title",
new Double(10),
new Date(),
"Samigo",
new Boolean(false),
catId);
fail();
} catch (ConflictingExternalIdException e) {
}
// Test a floating value.
double floatingPoints = 10.66666;
String floatingExtId = "Just another external ID";
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
floatingExtId,
null,
"AFractionalAssessment",
new Double(floatingPoints),
new Date(),
"Samigo",
new Boolean(false),
catId);
// Find the assessment and ensure that it has been updated
Assignment asn = null;
List assignments = gradebookManager.getAssignments(gbId);
for (Iterator iter = assignments.iterator(); iter.hasNext(); ) {
Assignment tmp = (Assignment) iter.next();
if (tmp.getExternalId() != null && tmp.getExternalId().equals(floatingExtId)) {
asn = tmp;
break;
}
}
Assert.assertEquals(asn.getPointsPossible(), new Double(floatingPoints));
}
/**
* Tests the gradebook service.
*
* @throws Exception
*/
public void testCreateExternalAssessment() throws Exception {
Assert.assertTrue(gradebookFrameworkService.isGradebookDefined(GRADEBOOK_UID));
// Make sure the service knows that the external id has not been defined
Assert.assertFalse(
gradebookExternalAssessmentService.isExternalAssignmentDefined(GRADEBOOK_UID, EXT_ID_1));
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
EXT_ID_1,
null,
EXT_TITLE_1,
new Double(10),
new Date(),
"Samigo",
new Boolean(false));
// Make sure the service knows that the external id has been defined
Assert.assertTrue(
gradebookExternalAssessmentService.isExternalAssignmentDefined(GRADEBOOK_UID, EXT_ID_1));
// Make sure that internal name conflicts are detected
try {
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
"A unique external id",
null,
ASN_1,
new Double(10),
new Date(),
"Samigo",
new Boolean(false));
fail();
} catch (ConflictingAssignmentNameException e) {
}
// Make sure that external name conflicts are detected
try {
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
"Another unique external id",
null,
EXT_TITLE_1,
new Double(10),
new Date(),
"Samigo",
new Boolean(false));
fail();
} catch (ConflictingAssignmentNameException e) {
}
// Make sure that external id conflicts are detected
try {
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
EXT_ID_1,
null,
"A unique title",
new Double(10),
new Date(),
"Samigo",
new Boolean(false));
fail();
} catch (ConflictingExternalIdException e) {
}
// Test a floating value.
double floatingPoints = 10.66666;
String floatingExtId = "Just another external ID";
gradebookExternalAssessmentService.addExternalAssessment(
GRADEBOOK_UID,
floatingExtId,
null,
"AFractionalAssessment",
new Double(floatingPoints),
new Date(),
"Samigo",
new Boolean(false));
// Find the assessment and ensure that it has been updated
Long gbId = gradebookManager.getGradebook(GRADEBOOK_UID).getId();
Assignment asn = null;
List assignments = gradebookManager.getAssignments(gbId);
for (Iterator iter = assignments.iterator(); iter.hasNext(); ) {
Assignment tmp = (Assignment) iter.next();
if (tmp.getExternalId() != null && tmp.getExternalId().equals(floatingExtId)) {
asn = tmp;
break;
}
}
Assert.assertEquals(asn.getPointsPossible(), new Double(floatingPoints));
}
