def clean(self): """ Validate the iospec_source field. """ super().clean() # We first should check if the iospec_source has been changed and thus # requires a possibly expensive validation. source = self.iospec_source iospec_hash = md5hash(source) if self.iospec_hash != iospec_hash: try: self.iospec = iospec.parse_string(self.iospec_source) except Exception: raise ValidationError( {'iospec_source': _('invalid iospec syntax')}) else: self.iospec_hash = iospec_hash if self.pk is None: self.is_usable = self.iospec.is_simple self.is_consistent = True else: self.is_usable = self._is_usable(self.iospec) self.is_consistent = self._is_consistent(self.iospec)
def parent_hash(self): """ Return the iospec hash from the question current iospec/iospec_size. """ parent = self.question return md5hash(parent.iospec_source + str(parent.iospec_size))
def get_response_hash(cls, response_data): """ Computes a hash for the response_data attribute. """ if response_data: data = json.dumps(response_data, default=json_default) return md5hash(data) return ''
def get_response_hash(cls, response_data): """ Computes a hash for the response_data attribute. """ if response_data: data = json.dumps(response_data, default=json_default) return md5hash(data) return ''
def update(self, commit=True): """ Update the internal iospec source and hash keys to match the given parent iospec value. It raises a ValidationError if the source code is invalid. """ iospec = self.question.iospec result = self._update_state(iospec, self.source, self.language) self.iospec_source = result.source() self.source_hash = md5hash(self.source) self.iospec_hash = self.parent_hash() if commit: self.save()
def clean(self): super().clean() if self.question is None: return # We only have to update if the parent's hash is incompatible with the # current hash and the source field is defined. We make this test to # perform the expensive code re-evaluation only when strictly necessary parent_hash = self.parent_hash() source_hash = md5hash(self.source) if parent_hash != self.iospec_hash or source_hash != self.source_hash: iospec = self.question.iospec result = self._update_state(iospec, self.source, self.language) self.iospec_source = result.source() self.source_hash = source_hash self.iospec_hash = parent_hash
def has_changed_source(self): """ Return True if source is not consistent with its hash. """ return self.source_hash != md5hash(self.source)
def save(self, *args, **kwargs): self.source_hash = md5hash(self.source) super().save(*args, **kwargs)
class AnswerKey(models.Model): """ Represents an answer to some question given in some specific computer language plus the placeholder text that should be displayed. """ NULL_SOURCE_HASH = md5hash('') class ValidationError(Exception): pass class Meta: verbose_name = _('answer key') verbose_name_plural = _('answer keys') unique_together = [('question', 'language')] question = models.ParentalKey( CodingIoQuestion, related_name='answers' ) language = models.ForeignKey( ProgrammingLanguage, related_name='+', ) source = models.TextField( _('answer source code'), blank=True, help_text=_( 'Source code for the correct answer in the given programming ' 'language.' ), ) placeholder = models.TextField( _('placeholder source code'), blank=True, help_text=_( 'This optional field controls which code should be placed in ' 'the source code editor when a question is opened. This is ' 'useful to put boilerplate or even a full program that the ' 'student should modify. It is possible to configure a global ' 'per-language boilerplate and leave this field blank.' ), ) source_hash = models.CharField( max_length=32, default=NULL_SOURCE_HASH, help_text=_('Hash computed from the reference source'), ) error_message = models.TextField( _('error message'), blank=True, help_text=_( 'If an error is found on post-validation, an error message is ' 'stored in here.' ) ) def __repr__(self): return '<AnswerKey: %s>' % self def __str__(self): try: title = self.question.title except: title = '<untitled>' return '%s (%s)' % (title, self.language) def save(self, *args, **kwargs): self.source_hash = md5hash(self.source) super().save(*args, **kwargs) def clean(self): try: check_syntax(self.source, lang=self.language.ejudge_ref()) except SyntaxError as ex: msg = _('Invalid syntax: %(msg)') % {'msg': str(ex)} raise ValidationError({'source': msg}) super().clean() # Validation is async: # # We first run basic validations in the foreground and later attempt # at more detailed validations that requires us to run source code (and # thus possibly wait a long time). # # If this later validation step encounters errors, it saves them on # the model instance. The next time the model runs, we can re-raise # them on the interface. The user has an option to bypass these checks. # Changing the code or the iospec entries should expire these # errors. if self.error_message and not self.is_ignoring_validation_errors(): raise ValidationError({'source': mark_safe(self.error_message)}) def is_ignoring_validation_errors(self): """ True to ignore errors found in post-validation. """ return self.question.ignore_validation_errors def set_error_message(self, message): """ Saves error message. """ try: self.error_message = message.__html__() except AttributeError: self.error_message = escape(message) def has_changed_source(self): """ Return True if source is not consistent with its hash. """ return self.source_hash != md5hash(self.source) # # # def single_reference(self): """ Return True if it is the only answer key in the set that defines a source attribute. """ if not self.source: return False try: return self.question.answers.has_program().get() == self except self.DoesNotExist: return False # Wagtail admin panels = [ panels.FieldPanel('language'), panels.FieldPanel('source'), panels.FieldPanel('placeholder'), ]
def compute_hash(self): return md5hash(self.source + self.language.ref)
def compute_hash(self): return md5hash(self.choice_id)
def compute_hash(self): return md5hash(self.source + self.language.ref)
def has_changed_source(self): """ Return True if source is not consistent with its hash. """ return self.source_hash != md5hash(self.source)
def save(self, *args, **kwargs): self.source_hash = md5hash(self.source) super().save(*args, **kwargs)