docs: def add_user(self, user, request=None, force=False, no_after_deadline=False, add_to_waitlist=False):
          """Sign up a user to this scheduled activity if possible. This is where the magic happens.
  
          Raises an exception if there's a problem signing the user up
          unless the signup is forced.
  
          """
          if request is not None:
              force = (force or ("force" in request.GET)) and request.user.is_eighth_admin
              add_to_waitlist = (add_to_waitlist or ("add_to_waitlist" in request.GET)) and request.user.is_eighth_admin
  
          exception = eighth_exceptions.SignupException()
  
          if user.grade and user.grade.number > 12:
              exception.SignupForbidden = True
  
          all_sched_act = [self]
          all_blocks = [self.block]
  
          if self.is_both_blocks():
              # Finds the other scheduling of the same activity on the same day
              # See note above in get_both_blocks_sibling()
              sibling = self.get_both_blocks_sibling()
  
              if sibling:
                  all_sched_act.append(sibling)
                  all_blocks.append(sibling.block)
  
          waitlist = None
          if not force:
              # Check if the user who sent the request has the permissions
              # to change the target user's signups
              if request is not None:
                  if user != request.user and not request.user.is_eighth_admin:
                      exception.SignupForbidden = True
  
              # Check if the activity has been deleted
              if self.activity.deleted:
                  exception.ActivityDeleted = True
  
              # Check if the user is already stickied into an activity
              in_stickie = (EighthSignup.objects.filter(user=user, scheduled_activity__activity__sticky=True,
                                                        scheduled_activity__block__in=all_blocks).exists())
  
              if not in_stickie:
                  in_stickie = (EighthSignup.objects.filter(user=user, scheduled_activity__sticky=True,
                                                            scheduled_activity__block__in=all_blocks).exists())
  
              if in_stickie:
                  exception.Sticky = True
  
              for sched_act in all_sched_act:
                  # Check if the block has been locked
                  if sched_act.block.locked:
                      exception.BlockLocked = True
  
                  # Check if the scheduled activity has been cancelled
                  if sched_act.cancelled:
                      exception.ScheduledActivityCancelled = True
  
                  # Check if the activity is full
                  if settings.ENABLE_WAITLIST and (add_to_waitlist or
                                                   (sched_act.is_full() and not self.is_both_blocks() and
                                                    (request is not None and not request.user.is_eighth_admin and request.user.is_student))):
                      if user.primary_email:
                          if EighthWaitlist.objects.filter(user_id=user.id, block_id=self.block.id).exists():
                              EighthWaitlist.objects.filter(user_id=user.id, block_id=self.block.id).delete()
                          waitlist = EighthWaitlist.objects.create(user=user, block=self.block, scheduled_activity=sched_act)
                      else:
                          exception.PrimaryEmailNotSet = True
                  elif sched_act.is_full():
                      exception.ActivityFull = True
  
              # Check if it's too early to sign up for the activity
              if self.activity.presign:
                  if self.is_too_early_to_signup():
                      exception.Presign = True
  
              # Check if signup would violate one-a-day constraint
              if not self.is_both_blocks() and self.activity.one_a_day:
                  in_act = (EighthSignup.objects.exclude(scheduled_activity__block=self.block).filter(
                      user=user, scheduled_activity__block__date=self.block.date, scheduled_activity__activity=self.activity).exists())
                  if in_act:
                      exception.OneADay = True
  
              # Check if user is allowed in the activity if it's restricted
              if self.get_restricted():
                  acts = EighthActivity.restricted_activities_available_to_user(user)
                  if self.activity.id not in acts:
                      exception.Restricted = True
  
              # Check if user is blacklisted from activity
              if self.activity.users_blacklisted.filter(username=user).exists():
                  exception.Blacklisted = True
  
          if force:
              EighthWaitlist.objects.filter(scheduled_activity_id=self.id, user_id=user.id, block_id=self.block.id).delete()
  
          if self.get_sticky():
              EighthWaitlist.objects.filter(user_id=user.id, block_id=self.block.id).delete()
  
          success_message = "Successfully added to waitlist for activity." if waitlist else "Successfully signed up for activity."
          """
          final_remove_signups = []
  
          # Check if the block overrides signups on other blocks
          if len(self.block.override_blocks.all()) > 0:
              override_blocks = self.block.override_blocks.all()
              can_change_out = True
  
              for block in override_blocks:
                  # If block is locked, can't change out of
                  if block.locked and not force:
                      exception.OverrideBlockLocked = [block]
                      can_change_out = False
                      break
  
                  signup_objs = (EighthSignup.objects
                                             .filter(user=user,
                                                     scheduled_activity__activity__sticky=True,
                                                     scheduled_activity__block=block))
                  in_stickie = signup_objs.exists()
                  if in_stickie and not force:
                      exception.OverrideBlockPermissions = [signup_objs[0].scheduled_activity.activity, block]
                      can_change_out = False
                      break
  
              # Going to change out of dependent activities at the end
              if can_change_out:
                  for block in override_blocks:
                      ovr_signups = EighthSignup.objects.filter(scheduled_activity__block=block, user=user)
                      for signup in ovr_signups:
                          logger.debug("Need to remove signup for {0}".format(signup))
                          final_remove_signups.append(signup)
          """
  
          # If we've collected any errors, raise the exception and abort
          # the signup attempt
          if exception.errors:
              raise exception
  
          # Everything's good to go - complete the signup. If we've gotten to
          # this point, the signup is either before deadline or performed by
          # an eighth period admin, so previous absences and passes are cleared.
          after_deadline = self.block.locked
  
          # If we're doing an eighth admin action (like signing up a group),
          # don't make an after deadline signup, which creates a pass.
          if no_after_deadline:
              after_deadline = False
          if not waitlist:
              if not self.is_both_blocks():
                  try:
                      existing_signup = EighthSignup.objects.get(user=user, scheduled_activity__block=self.block)
  
                      previous_activity_name = existing_signup.scheduled_activity.activity.name_with_flags
                      prev_sponsors = existing_signup.scheduled_activity.get_true_sponsors()
                      previous_activity_sponsors = ", ".join(map(str, prev_sponsors))
                      previous_activity = existing_signup.scheduled_activity
  
                      if not existing_signup.scheduled_activity.is_both_blocks():
                          existing_signup.scheduled_activity = self
                          existing_signup.after_deadline = after_deadline
                          existing_signup.was_absent = False
                          existing_signup.absence_acknowledged = False
                          existing_signup.pass_accepted = False
                          existing_signup.previous_activity_name = previous_activity_name
                          existing_signup.previous_activity_sponsors = previous_activity_sponsors
  
                          existing_signup.save()
                      else:
                          # Clear out the other signups for this block if the user is
                          # switching out of a both-blocks activity
                          sibling = existing_signup.scheduled_activity.get_both_blocks_sibling()
                          existing_blocks = [
                              existing_signup.scheduled_activity.block
                          ]
                          if sibling:
                              existing_blocks.append(sibling.block)
                          logger.debug(existing_blocks)
                          EighthSignup.objects.filter(user=user, scheduled_activity__block__in=existing_blocks).delete()
                          EighthWaitlist.objects.filter(user=user, scheduled_activity=self).delete()
                          EighthSignup.objects.create_signup(user=user, scheduled_activity=self, after_deadline=after_deadline,
                                                             previous_activity_name=previous_activity_name,
                                                             previous_activity_sponsors=previous_activity_sponsors, own_signup=(user == request.user))
                      if settings.ENABLE_WAITLIST and (previous_activity.waitlist.all().exists() and not self.block.locked and request is not None and
                                                       not request.session.get("disable_waitlist_transactions", False)):
                          if not previous_activity.is_full():
                              waitlists = EighthWaitlist.objects.get_next_waitlist(previous_activity)
                              self.notify_waitlist(waitlists, previous_activity)
  
                  except EighthSignup.DoesNotExist:
                      EighthSignup.objects.create_signup(user=user, scheduled_activity=self, after_deadline=after_deadline)
              else:
                  existing_signups = EighthSignup.objects.filter(user=user, scheduled_activity__block__in=all_blocks)
  
                  prev_data = {}
                  for signup in existing_signups:
                      prev_sponsors = signup.scheduled_activity.get_true_sponsors()
                      prev_data[signup.scheduled_activity.block.block_letter] = {
                          "name": signup.scheduled_activity.activity.name_with_flags,
                          "sponsors": ", ".join(map(str, prev_sponsors))
                      }
                  existing_signups.delete()
  
                  for sched_act in all_sched_act:
                      letter = sched_act.block.block_letter
                      if letter in prev_data:
                          previous_activity_name = prev_data[letter]["name"]
                          previous_activity_sponsors = prev_data[letter]["sponsors"]
                      else:
                          previous_activity_name = None
                          previous_activity_sponsors = None
  
                      EighthSignup.objects.create_signup(user=user, scheduled_activity=sched_act, after_deadline=after_deadline,
                                                         previous_activity_name=previous_activity_name,
                                                         previous_activity_sponsors=previous_activity_sponsors, own_signup=(user == request.user))
  
                      # signup.previous_activity_name = signup.activity.name_with_flags
                      # signup.previous_activity_sponsors = ", ".join(map(str, signup.get_true_sponsors()))
          """
          # See "If block overrides signup on other blocks" check
          # If there are EighthSignups that need to be removed, do them at the end
          for signup in final_remove_signups:
              success_message += "\nYour signup for {0} on {1} was removed. ".format(
                  signup.scheduled_activity.activity, signup.scheduled_activity.block)
              signup.delete()
          """
  
          return success_message