Ensure that peer grading modules whose linked problem is removed change over to panel mode

common/lib/xmodule/xmodule/peer_grading_module.py

@@ -104,30 +104,28 @@ class PeerGradingModule(PeerGradingFields, XModule):
     def __init__(self, *args, **kwargs):
         super(PeerGradingModule, self).__init__(*args, **kwargs)
 
-        #We need to set the location here so the child modules can use it
+        # Copy this to a new variable so that we can edit it if needed.
+        # We need to edit it if the linked module cannot be found, so
+        # we can revert to panel model.
+        self.use_for_single_location_local = self.use_for_single_location
+
+        # We need to set the location here so the child modules can use it.
         self.runtime.set('location', self.location)
         if (self.runtime.open_ended_grading_interface):
             self.peer_gs = PeerGradingService(self.system.open_ended_grading_interface, self.system)
         else:
             self.peer_gs = MockPeerGradingService()
 
-        if self.use_for_single_location:
-            try:
+        if self.use_for_single_location_local:
             linked_descriptors = self.descriptor.get_required_module_descriptors()
             if len(linked_descriptors) == 0:
                 error_msg = "Peer grading module {0} is trying to use single problem mode without "
                 "a location specified.".format(self.location)
                 log.error(error_msg)
-                    raise InvalidLinkLocation(error_msg)
+                # Change module over to panel mode from single problem mode.
+                self.use_for_single_location_local = False
+            else:
                 self.linked_problem = self.system.get_module(linked_descriptors[0])
-            except ItemNotFoundError:
-                log.error("Linked location {0} for peer grading module {1} does not exist".format(
-                    self.link_to_location, self.location))
-                raise
-            except NoPathToItem:
-                log.error("Linked location {0} for peer grading module {1} cannot be linked to.".format(
-                    self.link_to_location, self.location))
-                raise
 
         try:
             self.timeinfo = TimeInfo(self.due, self.graceperiod)
@@ -175,7 +173,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
         """
         if self.closed():
             return self.peer_grading_closed()
-        if not self.use_for_single_location:
+        if not self.use_for_single_location_local:
             return self.peer_grading()
         else:
             return self.peer_grading_problem({'location': self.link_to_location})['html']
@@ -236,7 +234,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
             'score': score,
             'total': max_score,
         }
-        if not self.use_for_single_location or not self.graded:
+        if not self.use_for_single_location_local or not self.graded:
             return score_dict
 
         try:
@@ -270,7 +268,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
               randomization, and 5/7 on another
         '''
         max_grade = None
-        if self.use_for_single_location and self.graded:
+        if self.use_for_single_location_local and self.graded:
             max_grade = self.weight
         return max_grade
 
@@ -492,7 +490,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
         Show the Peer grading closed template
         '''
         html = self.system.render_template('peer_grading/peer_grading_closed.html', {
-            'use_for_single_location': self.use_for_single_location
+            'use_for_single_location': self.use_for_single_location_local
         })
         return html
 
@@ -578,7 +576,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
             'error_text': error_text,
             # Checked above
             'staff_access': False,
-            'use_single_location': self.use_for_single_location,
+            'use_single_location': self.use_for_single_location_local,
         })
 
         return html
@@ -588,7 +586,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
         Show individual problem interface
         '''
         if data is None or data.get('location') is None:
-            if not self.use_for_single_location:
+            if not self.use_for_single_location_local:
                 # This is an error case, because it must be set to use a single location to be called without get parameters
                 # This is a dev_facing_error
                 log.error(
@@ -610,7 +608,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
             # Checked above
             'staff_access': False,
             'track_changes': getattr(module, 'track_changes', False),
-            'use_single_location': self.use_for_single_location,
+            'use_single_location': self.use_for_single_location_local,
         })
 
         return {'html': html, 'success': True}
@@ -656,10 +654,24 @@ class PeerGradingDescriptor(PeerGradingFields, RawDescriptor):
         return non_editable_fields
 
     def get_required_module_descriptors(self):
-        """Returns a list of XModuleDescritpor instances upon which this module depends, but are
-        not children of this module"""
+        """
+        Returns a list of XModuleDescriptor instances upon which this module depends, but are
+        not children of this module.
+        """
+
+        # If use_for_single_location is True, this is linked to an open ended problem.
         if self.use_for_single_location:
-            return [self.system.load_item(self.link_to_location)]
+            # Try to load the linked module.
+            # If we can't load it, return empty list to avoid exceptions on progress page.
+            try:
+                linked_module = self.system.load_item(self.link_to_location)
+                return [linked_module]
+            except (NoPathToItem, ItemNotFoundError):
+                error_message = ("Cannot find the combined open ended module "
+                                 "at location {0} being linked to from peer "
+                                 "grading module {1}").format(self.link_to_location, self.location)
+                log.error(error_message)
+                return []
         else:
             return []