Skip to content

armgit / zulip

Public Imported from GitHub
0

Zulip server and web application. Open-source team chat that helps teams stay productive and focused.

21.9 KB
Raw Blame
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import Optional, TypedDict, Union

from django.db.models import Sum
from django.utils.timezone import now as timezone_now

from corporate.lib.stripe import (
    BillingSession,
    RealmBillingSession,
    RemoteRealmBillingSession,
    RemoteServerBillingSession,
    get_configured_fixed_price_plan_offer,
    get_guest_user_count,
    get_non_guest_user_count,
    get_price_per_license,
    get_push_status_for_remote_request,
    start_of_next_billing_cycle,
)
from corporate.models.customers import Customer
from corporate.models.licenses import LicenseLedger
from corporate.models.plans import CustomerPlan, CustomerPlanOffer, get_current_plan_by_customer
from corporate.models.sponsorships import ZulipSponsorshipRequest
from zerver.actions.realm_settings import RealmDeactivationReasonType
from zerver.lib.timestamp import timestamp_to_datetime
from zerver.models import Realm, UserProfile
from zerver.models.realm_audit_logs import AuditLogEventType, RealmAuditLog
from zerver.models.realms import get_org_type_display_name
from zilencer.lib.remote_counts import MissingDataError
from zilencer.models import (
    RemoteCustomerUserCount,
    RemoteInstallationCount,
    RemotePushDeviceToken,
    RemoteRealm,
    RemoteRealmCount,
    RemoteServerBillingUser,
    RemoteServerDeactivationReasonType,
    RemoteZulipServer,
    RemoteZulipServerAuditLog,
    get_remote_realm_guest_and_non_guest_count,
    get_remote_server_guest_and_non_guest_count,
    has_stale_audit_log,
)

USER_DATA_STALE_WARNING = "Recent audit log missing: No data for used licenses."


class SponsorshipRequestDict(TypedDict):
    org_type: str
    org_website: str
    org_description: str
    plan_to_use_zulip: str
    total_users: str
    paid_users: str
    paid_users_description: str
    requested_plan: str


@dataclass
class SponsorshipData:
    sponsorship_pending: bool = False
    has_discount: bool = False
    monthly_discounted_price: int | None = None
    annual_discounted_price: int | None = None
    original_monthly_plan_price: int | None = None
    original_annual_plan_price: int | None = None
    minimum_licenses: int | None = None
    required_plan_tier: int | None = None
    latest_sponsorship_request: SponsorshipRequestDict | None = None


@dataclass
class NextPlanData:
    plan: Union["CustomerPlan", "CustomerPlanOffer", None] = None
    estimated_revenue: int | None = None


@dataclass
class PlanData:
    customer: Optional["Customer"] = None
    current_plan: Optional["CustomerPlan"] = None
    next_plan: Union["CustomerPlan", "CustomerPlanOffer", None] = None
    licenses: int | None = None
    licenses_used: int | None = None
    next_billing_cycle_start: datetime | None = None
    is_complimentary_access_plan: bool = False
    has_fixed_price: bool = False
    is_current_plan_billable: bool = False
    stripe_customer_url: str | None = None
    warning: str = ""
    annual_recurring_revenue: int | None = None
    estimated_next_plan_revenue: int | None = None


@dataclass
class PushNotificationsStatus:
    can_push: bool
    expected_end: datetime | None
    message: str


@dataclass
class MobilePushData:
    total_mobile_users: int
    push_notification_status: PushNotificationsStatus
    uncategorized_mobile_users: int | None = None
    mobile_pushes_forwarded: int | None = None
    last_mobile_push_sent: str = ""


@dataclass
class DeactivationData:
    event_time: datetime
    acting_user: UserProfile | None
    billing_user: RemoteServerBillingUser | None
    reason: RealmDeactivationReasonType | RemoteServerDeactivationReasonType | None


@dataclass
class RemoteSupportData:
    date_created: datetime
    has_stale_audit_log: bool
    plan_data: PlanData
    sponsorship_data: SponsorshipData
    user_data: RemoteCustomerUserCount
    mobile_push_data: MobilePushData
    deactivation_data: DeactivationData | None


@dataclass
class UserData:
    guest_user_count: int
    non_guest_user_count: int


@dataclass
class CloudSupportData:
    plan_data: PlanData
    sponsorship_data: SponsorshipData
    user_data: UserData
    file_upload_usage: str
    is_scrubbed: bool
    deactivation_data: DeactivationData | None


def get_stripe_customer_url(stripe_id: str) -> str:
    return f"https://dashboard.stripe.com/customers/{stripe_id}"  # nocoverage


def get_formatted_realm_upload_space_used(realm: Realm) -> str:  # nocoverage
    realm_bytes_used = realm.currently_used_upload_space_bytes()
    files_uploaded = realm_bytes_used > 0

    realm_uploads = "No uploads"
    if files_uploaded:
        realm_uploads = str(round(realm_bytes_used / 1024 / 1024, 2))

    quota = realm.upload_quota_bytes()
    if quota is None:
        if files_uploaded:
            return f"{realm_uploads} MiB / No quota"
        return f"{realm_uploads} / No quota"
    if quota == 0:
        return f"{realm_uploads} / 0.0 MiB"
    quota_mb = round(quota / 1024 / 1024, 2)
    return f"{realm_uploads} / {quota_mb} MiB"


def get_realm_user_data(realm: Realm) -> UserData:
    non_guests = get_non_guest_user_count(realm)
    guests = get_guest_user_count(realm)
    return UserData(
        guest_user_count=guests,
        non_guest_user_count=non_guests,
    )


def get_customer_sponsorship_data(customer: Customer) -> SponsorshipData:
    pending = customer.sponsorship_pending
    licenses = customer.minimum_licenses
    plan_tier = customer.required_plan_tier
    has_discount = False
    sponsorship_request = None
    monthly_discounted_price = None
    annual_discounted_price = None
    original_monthly_plan_price = None
    original_annual_plan_price = None
    if customer.monthly_discounted_price:
        has_discount = True
        monthly_discounted_price = customer.monthly_discounted_price
    if customer.annual_discounted_price:
        has_discount = True
        annual_discounted_price = customer.annual_discounted_price
    if plan_tier is not None:
        original_monthly_plan_price = get_price_per_license(
            plan_tier, CustomerPlan.BILLING_SCHEDULE_MONTHLY
        )
        original_annual_plan_price = get_price_per_license(
            plan_tier, CustomerPlan.BILLING_SCHEDULE_ANNUAL
        )
    if pending:
        last_sponsorship_request = (
            ZulipSponsorshipRequest.objects.filter(customer=customer).order_by("id").last()
        )
        if last_sponsorship_request is not None:
            org_type_name = get_org_type_display_name(last_sponsorship_request.org_type)
            if (
                last_sponsorship_request.org_website is None
                or last_sponsorship_request.org_website == ""
            ):
                website = "No website submitted"
            else:
                website = last_sponsorship_request.org_website
            sponsorship_request = SponsorshipRequestDict(
                org_type=org_type_name,
                org_website=website,
                org_description=last_sponsorship_request.org_description,
                total_users=last_sponsorship_request.expected_total_users,
                plan_to_use_zulip=last_sponsorship_request.plan_to_use_zulip,
                paid_users=last_sponsorship_request.paid_users_count,
                paid_users_description=last_sponsorship_request.paid_users_description,
                requested_plan=last_sponsorship_request.requested_plan,
            )

    return SponsorshipData(
        sponsorship_pending=pending,
        has_discount=has_discount,
        monthly_discounted_price=monthly_discounted_price,
        annual_discounted_price=annual_discounted_price,
        original_monthly_plan_price=original_monthly_plan_price,
        original_annual_plan_price=original_annual_plan_price,
        minimum_licenses=licenses,
        required_plan_tier=plan_tier,
        latest_sponsorship_request=sponsorship_request,
    )


def get_annual_invoice_count(billing_schedule: int) -> int:
    if billing_schedule == CustomerPlan.BILLING_SCHEDULE_MONTHLY:
        return 12
    else:  # nocoverage
        return 1


def get_next_plan_data(
    billing_session: BillingSession,
    customer: Customer,
    current_plan: CustomerPlan | None = None,
) -> NextPlanData:
    plan_offer: CustomerPlanOffer | None = None

    # A customer can have a CustomerPlanOffer with or without a current plan.
    if customer.required_plan_tier:
        plan_offer = get_configured_fixed_price_plan_offer(customer, customer.required_plan_tier)

    if plan_offer is not None:
        next_plan_data = NextPlanData(plan=plan_offer)
    elif current_plan is not None:
        next_plan_data = NextPlanData(plan=billing_session.get_next_plan(current_plan))
    else:
        next_plan_data = NextPlanData()

    if next_plan_data.plan is not None:
        if next_plan_data.plan.fixed_price is not None:
            next_plan_data.estimated_revenue = next_plan_data.plan.fixed_price
            return next_plan_data

        if current_plan is not None:
            licenses_at_next_renewal = current_plan.licenses_at_next_renewal()
            if licenses_at_next_renewal is not None:
                assert type(next_plan_data.plan) is CustomerPlan
                assert next_plan_data.plan.price_per_license is not None
                invoice_count = get_annual_invoice_count(next_plan_data.plan.billing_schedule)
                next_plan_data.estimated_revenue = (
                    next_plan_data.plan.price_per_license * licenses_at_next_renewal * invoice_count
                )
            else:
                next_plan_data.estimated_revenue = 0  # nocoverage
            return next_plan_data

    return next_plan_data


def get_plan_data_for_support_view(
    billing_session: BillingSession, user_count: int | None = None, stale_user_data: bool = False
) -> PlanData:
    customer = billing_session.get_customer()
    plan = None
    if customer is not None:
        plan = get_current_plan_by_customer(customer)
    plan_data = PlanData(
        customer=customer,
        current_plan=plan,
    )

    if plan_data.current_plan is not None:
        last_ledger_entry = (
            LicenseLedger.objects.filter(
                plan=plan_data.current_plan, event_time__lte=timezone_now()
            )
            .order_by("-id")
            .first()
        )

        if last_ledger_entry is None:  # nocoverage
            # This shouldn't be possible because at least one
            # license ledger entry should exist when a plan's
            # status is less than CustomerPlan.LIVE_STATUS_THRESHOLD.
            # But since we have a warning feature in the support
            # view for plan data, we use that instead of raising
            # an assertion error so that support staff can debug
            # if this does ever occur.
            plan_data.warning += "License ledger missing: No data for total licenses and revenue. "
            plan_data.licenses = None
            plan_data.annual_recurring_revenue = 0
        else:
            plan_data.licenses = last_ledger_entry.workplace_licenses
            plan_data.annual_recurring_revenue = (
                billing_session.get_annual_recurring_revenue_for_support_data(
                    plan_data.current_plan, last_ledger_entry
                )
            )

        # If we already have user count data, we use that
        # instead of querying the database again to get
        # the number of currently used licenses.
        if stale_user_data:
            plan_data.warning += USER_DATA_STALE_WARNING
            plan_data.licenses_used = None
        elif user_count is None:
            try:
                plan_data.licenses_used = (
                    billing_session.current_counts_for_billed_users().workplace_users
                )
            except MissingDataError:  # nocoverage
                plan_data.warning += USER_DATA_STALE_WARNING
                plan_data.licenses_used = None
        else:  # nocoverage
            plan_data.licenses_used = user_count

        if plan_data.current_plan.status in (
            CustomerPlan.FREE_TRIAL,
            CustomerPlan.DOWNGRADE_AT_END_OF_FREE_TRIAL,
        ):  # nocoverage
            assert plan_data.current_plan.next_invoice_date is not None
            plan_data.next_billing_cycle_start = plan_data.current_plan.next_invoice_date
        else:
            plan_data.next_billing_cycle_start = start_of_next_billing_cycle(
                plan_data.current_plan, timezone_now()
            )

        if isinstance(billing_session, RealmBillingSession):
            # TODO implement a complimentary access plan/tier for Zulip Cloud.
            plan_data.is_complimentary_access_plan = False
        else:
            plan_data.is_complimentary_access_plan = (
                plan_data.current_plan.tier == CustomerPlan.TIER_SELF_HOSTED_LEGACY
            )
        plan_data.has_fixed_price = plan_data.current_plan.fixed_price is not None
        plan_data.is_current_plan_billable = billing_session.check_plan_tier_is_billable(
            plan_tier=plan_data.current_plan.tier
        )

    # Check for a non-active/scheduled CustomerPlan or CustomerPlanOffer
    if customer is not None:
        next_plan_data = get_next_plan_data(billing_session, customer, plan_data.current_plan)
        plan_data.next_plan = next_plan_data.plan
        plan_data.estimated_next_plan_revenue = next_plan_data.estimated_revenue

    # If customer has a stripe ID, add link to stripe customer dashboard
    if customer is not None and customer.stripe_customer_id is not None:
        plan_data.stripe_customer_url = get_stripe_customer_url(
            customer.stripe_customer_id
        )  # nocoverage

    return plan_data


def get_mobile_push_data(remote_entity: RemoteZulipServer | RemoteRealm) -> MobilePushData:
    if isinstance(remote_entity, RemoteZulipServer):
        total_users = (
            RemotePushDeviceToken.objects.filter(server=remote_entity)
            .distinct("user_id", "user_uuid")
            .count()
        )
        uncategorized_users = (
            RemotePushDeviceToken.objects.filter(server=remote_entity, remote_realm__isnull=True)
            .distinct("user_id", "user_uuid")
            .count()
        )
        mobile_pushes = RemoteInstallationCount.objects.filter(
            server=remote_entity,
            property="mobile_pushes_forwarded::day",
            subgroup=None,
            end_time__gte=timezone_now() - timedelta(days=7),
        ).aggregate(total_forwarded=Sum("value", default=0))
        latest_remote_server_push_forwarded_count = RemoteInstallationCount.objects.filter(
            server=remote_entity,
            subgroup=None,
            property="mobile_pushes_forwarded::day",
        ).last()
        if latest_remote_server_push_forwarded_count is not None:  # nocoverage
            # mobile_pushes_forwarded is a CountStat with a day frequency,
            # so we want to show the start of the latest day interval.
            push_forwarded_interval_start = (
                (latest_remote_server_push_forwarded_count.end_time - timedelta(days=1))
                .date()
                .isoformat()
            )
        else:
            push_forwarded_interval_start = "None"
        push_status = get_push_status_for_remote_request(
            remote_server=remote_entity, remote_realm=None
        )
        push_notification_status = PushNotificationsStatus(
            can_push=push_status.can_push,
            expected_end=timestamp_to_datetime(push_status.expected_end_timestamp)
            if push_status.expected_end_timestamp
            else None,
            message=push_status.message,
        )
        return MobilePushData(
            total_mobile_users=total_users,
            push_notification_status=push_notification_status,
            uncategorized_mobile_users=uncategorized_users,
            mobile_pushes_forwarded=mobile_pushes["total_forwarded"],
            last_mobile_push_sent=push_forwarded_interval_start,
        )
    else:
        assert isinstance(remote_entity, RemoteRealm)
        mobile_users = (
            RemotePushDeviceToken.objects.filter(remote_realm=remote_entity)
            .distinct("user_id", "user_uuid")
            .count()
        )
        mobile_pushes = RemoteRealmCount.objects.filter(
            remote_realm=remote_entity,
            property="mobile_pushes_forwarded::day",
            subgroup=None,
            end_time__gte=timezone_now() - timedelta(days=7),
        ).aggregate(total_forwarded=Sum("value", default=0))
        latest_remote_realm_push_forwarded_count = RemoteRealmCount.objects.filter(
            remote_realm=remote_entity,
            subgroup=None,
            property="mobile_pushes_forwarded::day",
        ).last()
        if latest_remote_realm_push_forwarded_count is not None:  # nocoverage
            # mobile_pushes_forwarded is a CountStat with a day frequency,
            # so we want to show the start of the latest day interval.
            push_forwarded_interval_start = (
                (latest_remote_realm_push_forwarded_count.end_time - timedelta(days=1))
                .date()
                .isoformat()
            )
        else:
            push_forwarded_interval_start = "None"
        push_status = get_push_status_for_remote_request(remote_entity.server, remote_entity)
        push_notification_status = PushNotificationsStatus(
            can_push=push_status.can_push,
            expected_end=timestamp_to_datetime(push_status.expected_end_timestamp)
            if push_status.expected_end_timestamp
            else None,
            message=push_status.message,
        )
        return MobilePushData(
            total_mobile_users=mobile_users,
            push_notification_status=push_notification_status,
            uncategorized_mobile_users=None,
            mobile_pushes_forwarded=mobile_pushes["total_forwarded"],
            last_mobile_push_sent=push_forwarded_interval_start,
        )


def get_deactivation_data(audit_log: RealmAuditLog | RemoteZulipServerAuditLog) -> DeactivationData:
    event_time = audit_log.event_time

    acting_user = None
    billing_user = None
    reason = None
    if isinstance(audit_log, RealmAuditLog):
        if audit_log.acting_user:
            acting_user = audit_log.acting_user
        if audit_log.extra_data:
            reason = audit_log.extra_data.get("deactivation_reason", None)
    else:
        assert isinstance(audit_log, RemoteZulipServerAuditLog)
        if audit_log.acting_remote_user:
            billing_user = audit_log.acting_remote_user
        elif audit_log.acting_support_user:
            acting_user = audit_log.acting_support_user
        if audit_log.extra_data:
            reason = audit_log.extra_data.get("deactivation_reason", None)

    return DeactivationData(
        event_time=event_time,
        acting_user=acting_user,
        billing_user=billing_user,
        reason=reason,
    )


def get_data_for_remote_support_view(billing_session: BillingSession) -> RemoteSupportData:
    deactivation_data = None
    if isinstance(billing_session, RemoteServerBillingSession):
        user_data = get_remote_server_guest_and_non_guest_count(billing_session.remote_server.id)
        stale_audit_log_data = has_stale_audit_log(billing_session.remote_server)
        date_created = RemoteZulipServerAuditLog.objects.get(
            event_type=AuditLogEventType.REMOTE_SERVER_CREATED,
            server__id=billing_session.remote_server.id,
        ).event_time
        mobile_data = get_mobile_push_data(billing_session.remote_server)
        if billing_session.remote_server.deactivated:
            deactivation_audit_log = RemoteZulipServerAuditLog.objects.filter(
                server=billing_session.remote_server,
                event_type=AuditLogEventType.REMOTE_SERVER_DEACTIVATED,
            ).last()
            if deactivation_audit_log:
                deactivation_data = get_deactivation_data(deactivation_audit_log)
    else:
        assert isinstance(billing_session, RemoteRealmBillingSession)
        user_data = get_remote_realm_guest_and_non_guest_count(billing_session.remote_realm)
        stale_audit_log_data = has_stale_audit_log(billing_session.remote_realm.server)
        date_created = billing_session.remote_realm.realm_date_created
        mobile_data = get_mobile_push_data(billing_session.remote_realm)
    user_count = user_data.guest_user_count + user_data.non_guest_user_count
    plan_data = get_plan_data_for_support_view(billing_session, user_count, stale_audit_log_data)
    if plan_data.customer is not None:
        sponsorship_data = get_customer_sponsorship_data(plan_data.customer)
    else:
        sponsorship_data = SponsorshipData()

    return RemoteSupportData(
        date_created=date_created,
        has_stale_audit_log=stale_audit_log_data,
        plan_data=plan_data,
        sponsorship_data=sponsorship_data,
        user_data=user_data,
        mobile_push_data=mobile_data,
        deactivation_data=deactivation_data,
    )


def get_data_for_cloud_support_view(billing_session: BillingSession) -> CloudSupportData:
    assert isinstance(billing_session, RealmBillingSession)
    user_data = get_realm_user_data(billing_session.realm)
    plan_data = get_plan_data_for_support_view(billing_session)
    if plan_data.customer is not None:
        sponsorship_data = get_customer_sponsorship_data(plan_data.customer)
    else:
        sponsorship_data = SponsorshipData()

    deactivation_data = None
    if billing_session.realm.deactivated:
        deactivation_audit_log = RealmAuditLog.objects.filter(
            realm=billing_session.realm, event_type=AuditLogEventType.REALM_DEACTIVATED
        ).last()
        if deactivation_audit_log:
            deactivation_data = get_deactivation_data(deactivation_audit_log)

    return CloudSupportData(
        plan_data=plan_data,
        sponsorship_data=sponsorship_data,
        user_data=user_data,
        file_upload_usage=get_formatted_realm_upload_space_used(billing_session.realm),
        is_scrubbed=RealmAuditLog.objects.filter(
            realm=billing_session.realm, event_type=AuditLogEventType.REALM_SCRUBBED
        ).exists(),
        deactivation_data=deactivation_data,
    )