docs: def quick_scan(self, target_url, email_notify=None,
                     scan_profile='full_audit', path_list=('/',)):
          """
          :param target_url: The target url e.g. https://www.tagcube.io/
          :param email_notify: The notification email e.g. user@example.com
          :param scan_profile: The name of the scan profile
          :param path_list: The list of paths to use in the crawling bootstrap
  
          The basic idea around this method is to provide users with a quick way
          to start a new scan. We perform these steps:
  
              * If the domain in the target_url is not created, we create a new
              domain resource for it.
  
              * We verify that the user's license can scan the target domain (new
              or already created manually by the user)
  
              * We'll notify about this scan via email, if no email_notify is
              specified we'll use the TagCube's user email for notification. If
              there is no email notification for this email, we'll create one.
  
              * The scan will be started using the scan_profile and path_list
              provided as parameter.
  
          Lots of bad things can trigger errors. All errors trigger exceptions.
          Some of the situations where you'll get errors are:
  
              * The user's license can't scan the provided domain
  
              * We failed to connect to the REST API
  
              * The specified scan_profile does not exist
  
          :return: The newly generated scan id
          """
          #
          # Scan profile handling
          #
          scan_profile_resource = self.get_scan_profile(scan_profile)
          if scan_profile_resource is None:
              msg = 'The specified scan profile "%s" does not exist'
              raise ValueError(msg % scan_profile)
  
          #
          # Domain verification handling
          #
          domain = get_domain_from_url(target_url)
          port = get_port_from_url(target_url)
          is_ssl = use_ssl(target_url)
  
          # First, is there a domain resource to verify?
          domain_resource = self.get_domain(domain)
          if domain_resource is None:
              domain_resource = self.domain_add(domain)
  
          verification_resource = self.get_latest_verification(domain_resource.domain,
                                                               port, is_ssl)
  
          if verification_resource is None:
              # This seems to be the first scan to this domain, we'll have to
              # verify the client's ownership.
              #
              # Depending on the user's configuration, license, etc. this can
              # succeed or fail
              verification_resource = self.verification_add(domain_resource.id,
                                                            port, is_ssl)
  
              if not self.can_scan(verification_resource):
                  msg = verification_resource.get('verification_message', '')
                  raise ValueError(CAN_NOT_SCAN_DOMAIN_ERROR % msg)
  
          #
          # Email notification handling
          #
          notif_email = self.email if email_notify is None else email_notify
          email_notification_resource = self.get_email_notification(notif_email)
          if email_notification_resource is None:
              email_notification_resource = self.email_notification_add(notif_email)
  
          #
          # Scan!
          #
          return self.low_level_scan(verification_resource, scan_profile_resource,
                                     path_list, [email_notification_resource])