docs: def customerMeetsRequirement(self, customer, danceRole=None, registration=None):
          '''
          This method checks whether a given customer meets a given set of requirements.
          '''
  
          cust_reqs = self.customerrequirement_set.filter(customer=customer,met=True)
          if customer:
              cust_priors = customer.eventregistration_set.filter(event__series__isnull=False)
          else:
              cust_priors = EventRegistration.objects.none()
  
          # If there's an explicit object stating that this customer meets the requirement, then we're done.
          if self.roleEnforced and danceRole and cust_reqs.filter(role=danceRole).exists():
              return True
          elif not self.roleEnforced and cust_reqs.exists():
              return True
          elif self.roleEnforced and not danceRole:
              return False
  
          # Go through each item for this requirement and see if the customer meets that item
          for item in self.requirementitem_set.all():
              filter_dict = {}
              if item.requiredLevel:
                  filter_dict['event__series__classDescription__danceTypeLevel'] = item.requiredLevel
              if item.requiredClass:
                  filter_dict['event__series__classDescription'] = item.requiredClass
              if self.roleEnforced:
                  filter_dict['role'] = danceRole
  
              current_matches = 0
              overlap_matches = 0
              nonconcurrent_filter = {'event__endTime__lte': timezone.now()}
  
              if registration:
  
                  if isinstance(registration,Registration):
                      current_matches = registration.eventregistration_set.filter(**filter_dict).count()
                  elif isinstance(registration,TemporaryRegistration):
                      current_matches = registration.temporaryeventregistration_set.filter(**filter_dict).count()
  
                  nonconcurrent_filter = {'event__endTime__lte': registration.firstSeriesStartTime}
                  overlap_matches = cust_priors.filter(**filter_dict).exclude(**nonconcurrent_filter).filter(
                      event__startTime__lte=registration.lastSeriesEndTime,
                  ).count()
  
              priors_matches = cust_priors.filter(**filter_dict).filter(**nonconcurrent_filter).count()
  
              # The number of matches depends on the concurrency rule for this item
              if item.concurrentRule == item.ConcurrencyRule.prohibited:
                  matches = priors_matches
              elif item.concurrentRule == item.ConcurrencyRule.allowOneOverlapClass:
                  matches = priors_matches + \
                      cust_priors.filter(**filter_dict).exclude(**nonconcurrent_filter).filter(
                          event__startTime__lte=registration.getTimeOfClassesRemaining(1)
                      ).count()
              elif item.concurrentRule == item.ConcurrencyRule.allowTwoOverlapClasses:
                  matches = priors_matches + \
                      cust_priors.filter(**filter_dict).exclude(**nonconcurrent_filter).filter(
                          event__startTime__lte=registration.getTimeOfClassesRemaining(2)
                      ).count()
              elif item.concurrentRule == item.ConcurrencyRule.allowed:
                  matches = priors_matches + overlap_matches + \
                      (current_matches if isinstance(registration,TemporaryRegistration) else 0)
              elif item.concurrentRule == item.ConcurrencyRule.required:
                  matches = overlap_matches + current_matches
  
              if matches >= item.quantity:
                  # If this is an 'or' or a 'not' requirement, then we are done
                  if self.booleanRule == self.BooleanChoice.booleanOr:
                      return True
                  if self.booleanRule == self.BooleanChoice.booleanNot:
                      return False
              else:
                  # If this is an 'and' requirement and we didn't meet, then we are done
                  if self.booleanRule == self.BooleanChoice.booleanAnd:
                      return False
  
          # If we got this far, then either all 'and' requirements were met, or all 'or' and 'not' requirements were not met
          if self.booleanRule == self.BooleanChoice.booleanOr or self.requirementitem_set.count() == 0:
              return False
          return True