text: from datetime import timedelta
  from secrets import token_urlsafe
  import uuid
  
  from django.conf import settings
  from django.contrib.auth.hashers import check_password, make_password
  from django.contrib.auth.models import User
  from django.core.signing import TimestampSigner
  from django.db import models
  from django.db.models import Count, Q
  from django.urls import reverse
  from django.utils import timezone
  from hc.lib import emails
  from hc.lib.date import month_boundaries
  
  
  NO_NAG = timedelta()
  NAG_PERIODS = (
      (NO_NAG, "Disabled"),
      (timedelta(hours=1), "Hourly"),
      (timedelta(days=1), "Daily"),
  )
  
  
  def month(dt):
      """ For a given datetime, return the matching first-day-of-month date. """
      return dt.date().replace(day=1)
  
  
  class ProfileManager(models.Manager):
      def for_user(self, user):
          try:
              return user.profile
          except Profile.DoesNotExist:
              profile = Profile(user=user)
              if not settings.USE_PAYMENTS:
                  # If not using payments, set high limits
                  profile.check_limit = 500
                  profile.sms_limit = 500
                  profile.team_limit = 500
  
              profile.save()
              return profile
  
  
  class Profile(models.Model):
      user = models.OneToOneField(User, models.CASCADE, blank=True, null=True)
      next_report_date = models.DateTimeField(null=True, blank=True)
      reports_allowed = models.BooleanField(default=True)
      nag_period = models.DurationField(default=NO_NAG, choices=NAG_PERIODS)
      next_nag_date = models.DateTimeField(null=True, blank=True)
      ping_log_limit = models.IntegerField(default=100)
      check_limit = models.IntegerField(default=20)
      token = models.CharField(max_length=128, blank=True)
      last_sms_date = models.DateTimeField(null=True, blank=True)
      sms_limit = models.IntegerField(default=5)
      sms_sent = models.IntegerField(default=0)
      team_limit = models.IntegerField(default=2)
      sort = models.CharField(max_length=20, default="created")
      deletion_notice_date = models.DateTimeField(null=True, blank=True)
      last_active_date = models.DateTimeField(null=True, blank=True)
  
      objects = ProfileManager()
  
      def __str__(self):
          return "Profile for %s" % self.user.email
  
      def notifications_url(self):
          return settings.SITE_ROOT + reverse("hc-notifications")
  
      def reports_unsub_url(self):
          signer = TimestampSigner(salt="reports")
          signed_username = signer.sign(self.user.username)
          path = reverse("hc-unsubscribe-reports", args=[signed_username])
          return settings.SITE_ROOT + path
  
      def prepare_token(self, salt):
          token = token_urlsafe(24)
          self.token = make_password(token, salt)
          self.save()
          return token
  
      def check_token(self, token, salt):
          return salt in self.token and check_password(token, self.token)
  
      def send_instant_login_link(self, inviting_project=None, redirect_url=None):
          token = self.prepare_token("login")
          path = reverse("hc-check-token", args=[self.user.username, token])
          if redirect_url:
              path += "?next=%s" % redirect_url
  
          ctx = {
              "button_text": "Sign In",
              "button_url": settings.SITE_ROOT + path,
              "inviting_project": inviting_project,
          }
          emails.login(self.user.email, ctx)
  
      def send_set_password_link(self):
          token = self.prepare_token("set-password")
          path = reverse("hc-set-password", args=[token])
          ctx = {"button_text": "Set Password", "button_url": settings.SITE_ROOT + path}
          emails.set_password(self.user.email, ctx)
  
      def send_change_email_link(self):
          token = self.prepare_token("change-email")
          path = reverse("hc-change-email", args=[token])
          ctx = {"button_text": "Change Email", "button_url": settings.SITE_ROOT + path}
          emails.change_email(self.user.email, ctx)
  
      def send_sms_limit_notice(self, transport):
          ctx = {"transport": transport, "limit": self.sms_limit}
          if self.sms_limit != 500 and settings.USE_PAYMENTS:
              ctx["url"] = settings.SITE_ROOT + reverse("hc-pricing")
  
          emails.sms_limit(self.user.email, ctx)
  
      def projects(self):
          """ Return a queryset of all projects we have access to. """
  
          is_owner = Q(owner=self.user)
          is_member = Q(member__user=self.user)
          q = Project.objects.filter(is_owner | is_member)
          return q.distinct().order_by("name")
  
      def annotated_projects(self):
          """ Return all projects, annotated with 'n_down'. """
  
          # Subquery for getting project ids
          project_ids = self.projects().values("id")
  
          # Main query with the n_down annotation.
          # Must use the subquery, otherwise ORM gets confused by
          # joins and group by's
          q = Project.objects.filter(id__in=project_ids)
          n_down = Count("check", filter=Q(check__status="down"))
          q = q.annotate(n_down=n_down)
          return q.order_by("name")
  
      def checks_from_all_projects(self):
          """ Return a queryset of checks from projects we have access to. """
  
          project_ids = self.projects().values("id")
  
          from hc.api.models import Check
  
          return Check.objects.filter(project_id__in=project_ids)
  
      def send_report(self, nag=False):
          checks = self.checks_from_all_projects()
  
          # Has there been a ping in last 6 months?
          result = checks.aggregate(models.Max("last_ping"))
          last_ping = result["last_ping__max"]
  
          six_months_ago = timezone.now() - timedelta(days=180)
          if last_ping is None or last_ping < six_months_ago:
              return False
  
          # Is there at least one check that is down?
          num_down = checks.filter(status="down").count()
          if nag and num_down == 0:
              return False
  
          # Sort checks by project. Need this because will group by project in
          # template.
          checks = checks.select_related("project")
          checks = checks.order_by("project_id")
          # list() executes the query, to avoid DB access while
          # rendering the template
          checks = list(checks)
  
          unsub_url = self.reports_unsub_url()
  
          headers = {
              "List-Unsubscribe": "<%s>" % unsub_url,
              "X-Bounce-Url": unsub_url,
              "List-Unsubscribe-Post": "List-Unsubscribe=One-Click",
          }
  
          ctx = {
              "checks": checks,
              "sort": self.sort,
              "now": timezone.now(),
              "unsub_link": unsub_url,
              "notifications_url": self.notifications_url(),
              "nag": nag,
              "nag_period": self.nag_period.total_seconds(),
              "num_down": num_down,
              "month_boundaries": month_boundaries(),
          }
  
          emails.report(self.user.email, ctx, headers)
          return True
  
      def sms_sent_this_month(self):
          # IF last_sms_date was never set, we have not sent any messages yet.
          if not self.last_sms_date:
              return 0
  
          # If last sent date is not from this month, we've sent 0 this month.
          if month(timezone.now()) > month(self.last_sms_date):
              return 0
  
          return self.sms_sent
  
      def authorize_sms(self):
          """ If monthly limit not exceeded, increase counter and return True """
  
          sent_this_month = self.sms_sent_this_month()
          if sent_this_month >= self.sms_limit:
              return False
  
          self.sms_sent = sent_this_month + 1
          self.last_sms_date = timezone.now()
          self.save()
          return True
  
  
  class Project(models.Model):
      code = models.UUIDField(default=uuid.uuid4, unique=True)
      name = models.CharField(max_length=200, blank=True)
      owner = models.ForeignKey(User, models.CASCADE)
      api_key = models.CharField(max_length=128, blank=True, db_index=True)
      api_key_readonly = models.CharField(max_length=128, blank=True, db_index=True)
      badge_key = models.CharField(max_length=150, unique=True)
  
      def __str__(self):
          return self.name or self.owner.email
  
      @property
      def owner_profile(self):
          return Profile.objects.for_user(self.owner)
  
      def num_checks_available(self):
          from hc.api.models import Check
  
          num_used = Check.objects.filter(project__owner=self.owner).count()
          return self.owner_profile.check_limit - num_used
  
      def set_api_keys(self):
          self.api_key = token_urlsafe(nbytes=24)
          self.api_key_readonly = token_urlsafe(nbytes=24)
          self.save()
  
      def team(self):
          return User.objects.filter(memberships__project=self).order_by("email")
  
      def invite_suggestions(self):
          q = User.objects.filter(memberships__project__owner_id=self.owner_id)
          q = q.exclude(memberships__project=self)
          return q.distinct().order_by("email")
  
      def can_invite_new_users(self):
          q = User.objects.filter(memberships__project__owner_id=self.owner_id)
          used = q.distinct().count()
          return used < self.owner_profile.team_limit
  
      def invite(self, user):
          Member.objects.create(user=user, project=self)
          user.profile.send_instant_login_link(self)
  
      def set_next_nag_date(self):
          """ Set next_nag_date on profiles of all members of this project. """
  
          is_owner = Q(user=self.owner)
          is_member = Q(user__memberships__project=self)
          q = Profile.objects.filter(is_owner | is_member)
          q = q.exclude(nag_period=NO_NAG)
          # Exclude profiles with next_nag_date already set
          q = q.filter(next_nag_date__isnull=True)
  
          q.update(next_nag_date=timezone.now() + models.F("nag_period"))
  
      def overall_status(self):
          status = "up"
          for check in self.check_set.all():
              check_status = check.get_status(with_started=False)
              if status == "up" and check_status == "grace":
                  status = "grace"
  
              if check_status == "down":
                  status = "down"
                  break
          return status
  
      def have_channel_issues(self):
          errors = list(self.channel_set.values_list("last_error", flat=True))
  
          # It's a problem if a project has no integrations at all
          if len(errors) == 0:
              return True
  
          # It's a problem if any integration has a logged error
          return True if max(errors) else False
  
  
  class Member(models.Model):
      user = models.ForeignKey(User, models.CASCADE, related_name="memberships")
      project = models.ForeignKey(Project, models.CASCADE)
  