Remove upgrade protection enums

src/Frontend/src/components/LicenseExpired.vue

@@ -2,6 +2,7 @@
 import routeLinks from "@/router/routeLinks";
 import ExternalLink from "@/components/ExternalLink.vue";
 import { useLicenseStore } from "@/stores/LicenseStore";
+import { upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 
 const licenseStore = useLicenseStore();
 const { licenseStatus, license } = licenseStore;
@@ -27,10 +28,10 @@ const { licenseStatus, license } = licenseStore;
       </div>
     </div>
   </template>
-  <template v-if="licenseStatus.isInvalidDueToUpgradeProtectionExpired">
+  <template v-if="licenseStatus.isUpgradeProtectionUnsupported">
     <div class="text-center monitoring-no-data">
-      <h1>Platform license expired</h1>
-      <p>Your upgrade protection period has elapsed and your license is not valid for this version of ServicePulse.</p>
+      <h1>Platform license no longer supported</h1>
+      <p>{{ upgradeProtectionUnsupportedMessage }} Please update your license to continue using the Particular Service Platform.</p>
       <div class="action-toolbar">
         <RouterLink class="btn btn-default btn-primary" :to="routeLinks.configuration.license.link">View license details</RouterLink>
       </div>

src/Frontend/src/components/LicenseNotExpired.vue

@@ -8,7 +8,7 @@ const { licenseStatus } = licenseStore;
 </script>
 
 <template>
-  <ConditionalRender :supported="!licenseStatus.isExpired">
+  <ConditionalRender :supported="!licenseStatus.isInvalid">
     <template #unsupported>
       <LicenseExpired />
     </template>

src/Frontend/src/components/LicenseNotificationPopup.vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { computed } from "vue";
 import { TYPE } from "vue-toastification";
-import { LicenseStatus } from "@/resources/LicenseInfo";
+import { LicenseStatus, upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 
 const props = defineProps<{
   type: TYPE.WARNING | TYPE.ERROR;
@@ -13,14 +13,10 @@ const props = defineProps<{
 
 const heading = computed(() => {
   switch (props.licenseStatus) {
-    case LicenseStatus.ValidWithExpiredUpgradeProtection:
-      return "Upgrade protection expired";
     case LicenseStatus.ValidWithExpiringTrial:
       return props.isMassTransitConnector ? "Early Access license expiring" : "Non-production development license expiring";
     case LicenseStatus.ValidWithExpiringSubscription:
       return "Platform license expires soon";
-    case LicenseStatus.ValidWithExpiringUpgradeProtection:
-      return "Upgrade protection expires soon";
     default:
       return "";
   }
@@ -33,14 +29,16 @@ const heading = computed(() => {
       <p>
         <strong>{{ props.type === TYPE.ERROR ? "Error" : "" }}</strong>
       </p>
-      <span v-if="props.type === TYPE.ERROR">Your license has expired. Please contact Particular Software support at: <a href="https://particular.net/support">https://particular.net/support</a></span>
+      <span v-if="props.type === TYPE.ERROR">
+        {{ props.licenseStatus === LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported ? upgradeProtectionUnsupportedMessage : "Your license has expired." }}
+        Please contact Particular Software support at: <a href="https://particular.net/support">https://particular.net/support</a>
+      </span>
       <div v-else>
         <strong>{{ heading }}</strong>
         <div v-if="props.licenseStatus === LicenseStatus.ValidWithExpiringTrial">
           Your {{ props.isMassTransitConnector ? "Early Access" : "non-production development" }} license will expire soon. To continue using the Particular Service Platform you'll need to extend your license.
         </div>
         <div v-else-if="props.licenseStatus === LicenseStatus.ValidWithExpiringSubscription">Once the license expires you'll no longer be able to continue using the Particular Service Platform.</div>
-        <div v-else>Once upgrade protection expires, you'll no longer have access to support or new product versions</div>
         <a v-if="props.licenseStatus === LicenseStatus.ValidWithExpiringTrial" :href="props.licenseExtensionUrl" class="btn btn-warning">Extend your license</a>
         <a :href="props.configurationRootLink" class="btn" :class="props.licenseStatus === LicenseStatus.ValidWithExpiringTrial ? 'btn-light' : 'btn-warning'">View license details</a>
       </div>

src/Frontend/src/components/LicenseNotifications.spec.ts

@@ -6,7 +6,7 @@ import { TYPE } from "vue-toastification";
 import LicenseNotifications from "@/components/LicenseNotifications.vue";
 import LicenseNotificationPopup from "@/components/LicenseNotificationPopup.vue";
 import { useShowToast } from "@/composables/toast";
-import { LicenseStatus } from "@/resources/LicenseInfo";
+import { LicenseStatus, upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 import routeLinks from "@/router/routeLinks";
 import { useConfigurationStore } from "@/stores/ConfigurationStore";
 import { useLicenseStore } from "@/stores/LicenseStore";
@@ -35,18 +35,6 @@ describe("LicenseNotifications", () => {
       heading: "Early Access license expiring",
       body: "Your Early Access license will expire soon. To continue using the Particular Service Platform you'll need to extend your license.",
     },
-    {
-      status: LicenseStatus.ValidWithExpiredUpgradeProtection,
-      isMassTransitConnector: false,
-      heading: "Upgrade protection expired",
-      body: "Once upgrade protection expires, you'll no longer have access to support or new product versions",
-    },
-    {
-      status: LicenseStatus.ValidWithExpiringUpgradeProtection,
-      isMassTransitConnector: false,
-      heading: "Upgrade protection expires soon",
-      body: "Once upgrade protection expires, you'll no longer have access to support or new product versions",
-    },
     {
       status: LicenseStatus.ValidWithExpiringSubscription,
       isMassTransitConnector: false,
@@ -78,15 +66,19 @@ describe("LicenseNotifications", () => {
     }
   });
 
-  test.each([LicenseStatus.InvalidDueToExpiredTrial, LicenseStatus.InvalidDueToExpiredSubscription, LicenseStatus.InvalidDueToExpiredUpgradeProtection])("renders a persistent error for %s", async (status) => {
+  test.each([
+    { status: LicenseStatus.InvalidDueToExpiredTrial, message: "Your license has expired. Please contact Particular Software support at:" },
+    { status: LicenseStatus.InvalidDueToExpiredSubscription, message: "Your license has expired. Please contact Particular Software support at:" },
+    { status: LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported, message: `${upgradeProtectionUnsupportedMessage} Please contact Particular Software support at:` },
+  ])("renders a persistent error for $status", async ({ status, message }) => {
     const { licenseStore } = renderNotifications();
     licenseStore.license.license_status = status;
     await nextTick();
 
     const { container } = renderNotification(TYPE.ERROR, status);
 
     expect(screen.getByText("Error")).toBeInTheDocument();
-    expect(screen.getByText("Your license has expired. Please contact Particular Software support at:")).toBeInTheDocument();
+    expect(screen.getByText(message)).toBeInTheDocument();
     expect(container.querySelector(".toast-message.toast-error")).toBeInTheDocument();
     const support = screen.getByRole("link", { name: "https://particular.net/support" });
     expect(support).toHaveAttribute("href", "https://particular.net/support");

src/Frontend/src/components/LicenseNotifications.vue

@@ -21,15 +21,13 @@ function displayWarningMessage(licenseStatus: LicenseStatus) {
   const configurationRootLink = router.resolve(routeLinks.configuration.root).href;
   let type: TYPE.WARNING | TYPE.ERROR;
   switch (licenseStatus) {
-    case LicenseStatus.ValidWithExpiredUpgradeProtection:
     case LicenseStatus.ValidWithExpiringTrial:
     case LicenseStatus.ValidWithExpiringSubscription:
-    case LicenseStatus.ValidWithExpiringUpgradeProtection:
       type = TYPE.WARNING;
       break;
     case LicenseStatus.InvalidDueToExpiredTrial:
     case LicenseStatus.InvalidDueToExpiredSubscription:
-    case LicenseStatus.InvalidDueToExpiredUpgradeProtection:
+    case LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported:
       type = TYPE.ERROR;
       break;
     default:

src/Frontend/src/components/configuration/PlatformLicense.vue

@@ -2,7 +2,7 @@
 import ServiceControlAvailable from "../ServiceControlAvailable.vue";
 import ExclamationMark from "./../../components/ExclamationMark.vue";
 import convertToWarningLevel from "@/components/configuration/convertToWarningLevel";
-import { typeText } from "@/resources/LicenseInfo";
+import { typeText, upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 import ExternalLink from "@/components/ExternalLink.vue";
 import { useConfigurationStore } from "@/stores/ConfigurationStore";
 import { storeToRefs } from "pinia";
@@ -71,18 +71,17 @@ const { licenseStatus, license } = licenseStore;
                       role="note"
                       aria-label="license-expiry-date"
                       :class="{
-                        'license-expired': licenseStatus.isInvalidDueToUpgradeProtectionExpired,
+                        'license-expired': licenseStatus.isUpgradeProtectionUnsupported,
                       }"
                     >
                       {{ formattedUpgradeProtectionExpiration }}
                       <span role="note" aria-label="license-days-left">{{ licenseStatus.upgradeDaysLeft }}</span>
                       <exclamation-mark :type="convertToWarningLevel(licenseStatus.warningLevel)" />
                     </span>
                   </DetailsItem>
-                  <div class="license-expired-text" role="note" aria-label="license-expired" v-if="licenseStatus.isValidWithExpiredUpgradeProtection || licenseStatus.isValidWithExpiringUpgradeProtection">
-                    <b>Warning:</b> Once upgrade protection expires, you'll no longer have access to support or new product versions.
+                  <div class="license-expired-text" role="note" aria-label="license-unsupported" v-if="licenseStatus.isUpgradeProtectionUnsupported">
+                    {{ upgradeProtectionUnsupportedMessage }} Please update your license to continue using the Particular Service Platform.
                   </div>
-                  <div class="license-expired-text" v-if="licenseStatus.isInvalidDueToUpgradeProtectionExpired">Your license upgrade protection expired before this version of ServicePulse was released.</div>
                 </template>
                 <DetailsItem label="ServiceControl Instance">
                   {{ formattedInstanceName }}

src/Frontend/src/resources/LicenseInfo.ts

@@ -1,5 +1,7 @@
 import type Configuration from "./Configuration";
 
+export const upgradeProtectionUnsupportedMessage = "Your upgrade protection license is no longer supported.";
+
 export interface LicensedProduct {
   name: string;
   quantity: number;
@@ -32,9 +34,7 @@ export enum LicenseStatus {
   InvalidDueToExpiredSubscription = "InvalidDueToExpiredSubscription",
   ValidWithExpiringTrial = "ValidWithExpiringTrial",
   InvalidDueToExpiredTrial = "InvalidDueToExpiredTrial",
-  InvalidDueToExpiredUpgradeProtection = "InvalidDueToExpiredUpgradeProtection",
-  ValidWithExpiredUpgradeProtection = "ValidWithExpiredUpgradeProtection",
-  ValidWithExpiringUpgradeProtection = "ValidWithExpiringUpgradeProtection",
+  InvalidDueToUpgradeProtectionNoLongerBeingSupported = "InvalidDueToUpgradeProtectionNoLongerBeingSupported",
   ValidWithExpiringSubscription = "ValidWithExpiringSubscription",
 }
 export enum LicenseType {

src/Frontend/src/stores/LicenseStore.ts

@@ -31,10 +31,8 @@ export const useLicenseStore = defineStore("LicenseStore", () => {
     isPlatformExpired: false,
     isPlatformTrialExpired: false,
     isPlatformTrialExpiring: false,
-    isInvalidDueToUpgradeProtectionExpired: false,
-    isValidWithExpiredUpgradeProtection: false,
-    isValidWithExpiringUpgradeProtection: false,
-    isExpired: false,
+    isUpgradeProtectionUnsupported: false,
+    isInvalid: false,
     upgradeDaysLeft: "",
     subscriptionDaysLeft: "",
     trialDaysLeft: "",
@@ -93,14 +91,12 @@ export const useLicenseStore = defineStore("LicenseStore", () => {
       licenseStatus.isPlatformExpired = license.license_status === LicenseStatus.InvalidDueToExpiredSubscription;
       licenseStatus.isPlatformTrialExpiring = license.license_status === LicenseStatus.ValidWithExpiringTrial;
       licenseStatus.isPlatformTrialExpired = license.license_status === LicenseStatus.InvalidDueToExpiredTrial;
-      licenseStatus.isInvalidDueToUpgradeProtectionExpired = license.license_status === LicenseStatus.InvalidDueToExpiredUpgradeProtection;
-      licenseStatus.isValidWithExpiredUpgradeProtection = license.license_status === LicenseStatus.ValidWithExpiredUpgradeProtection;
-      licenseStatus.isValidWithExpiringUpgradeProtection = license.license_status === LicenseStatus.ValidWithExpiringUpgradeProtection;
+      licenseStatus.isUpgradeProtectionUnsupported = license.license_status === LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported;
       licenseStatus.upgradeDaysLeft = getUpgradeDaysLeft();
       licenseStatus.subscriptionDaysLeft = getSubscriptionDaysLeft();
       licenseStatus.trialDaysLeft = getTrialDaysLeft();
       licenseStatus.warningLevel = getLicenseWarningLevel();
-      licenseStatus.isExpired = licenseStatus.isPlatformExpired || licenseStatus.isPlatformTrialExpired || licenseStatus.isInvalidDueToUpgradeProtectionExpired;
+      licenseStatus.isInvalid = licenseStatus.isPlatformExpired || licenseStatus.isPlatformTrialExpired || licenseStatus.isUpgradeProtectionUnsupported;
       licenseStatus.licenseExtensionUrl = license.license_extension_url;
     } finally {
       loading.value = false;
@@ -121,11 +117,9 @@ export const useLicenseStore = defineStore("LicenseStore", () => {
     switch (license.license_status) {
       case LicenseStatus.InvalidDueToExpiredTrial:
       case LicenseStatus.InvalidDueToExpiredSubscription:
-      case LicenseStatus.InvalidDueToExpiredUpgradeProtection:
+      case LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported:
         return LicenseWarningLevel.Danger;
-      case LicenseStatus.ValidWithExpiringUpgradeProtection:
       case LicenseStatus.ValidWithExpiringTrial:
-      case LicenseStatus.ValidWithExpiredUpgradeProtection:
       case LicenseStatus.ValidWithExpiringSubscription:
         return LicenseWarningLevel.Warning;
       default:
@@ -165,7 +159,7 @@ export const useLicenseStore = defineStore("LicenseStore", () => {
   }
 
   function getUpgradeDaysLeft() {
-    if (license.license_status === LicenseStatus.InvalidDueToExpiredUpgradeProtection) return " - expired";
+    if (license.license_status === LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported) return " - no longer supported";
 
     const expiringIn = useGetDayDiffFromToday(license.upgrade_protection_expiration);
     //TODO: can this be unified with the function above? Text is currently similar but not identical.

src/Frontend/src/views/ConfigurationView.vue

@@ -95,7 +95,7 @@ function preventIfDisabled(e: Event, disabled: boolean) {
             <RouterLink :to="routeLinks.throughput.setup.root">Usage Setup</RouterLink>
             <exclamation-mark :type="WarningLevel.Danger" v-if="hasErrors" />
           </h5>
-          <template v-if="!licenseStatus.isExpired">
+          <template v-if="!licenseStatus.isInvalid">
             <h5
               :class="{
                 active: isRouteSelected(routeLinks.configuration.massTransitConnector.link),

src/Frontend/test/preconditions/licensing.ts

@@ -21,8 +21,9 @@ export const hasActiveLicense = ({ driver }: SetupFactoryOptions) => {
   });
   return licenseResponseTemplate;
 };
-export const hasExpiredLicense = (licenseType: LicenseType, expiredDays: number = 10, extensionUrl: string = "") => getLicenseMockedResponse(licenseType, expiredDays, extensionUrl, true);
-export const hasExpiringLicense = (licenseType: LicenseType, expiringInDays: number = 10, extensionUrl: string = "") => getLicenseMockedResponse(licenseType, expiringInDays, extensionUrl, false);
+export const hasExpiredLicense = (licenseType: LicenseType.Subscription | LicenseType.Trial, expiredDays: number = 10, extensionUrl: string = "") => getLicenseMockedResponse(licenseType, expiredDays, extensionUrl, true);
+export const hasExpiringLicense = (licenseType: LicenseType.Subscription | LicenseType.Trial, expiringInDays: number = 10, extensionUrl: string = "") => getLicenseMockedResponse(licenseType, expiringInDays, extensionUrl, false);
+export const hasUnsupportedUpgradeProtectionLicense = (protectionDateOffset: number = 10) => getLicenseMockedResponse(LicenseType.UpgradeProtection, protectionDateOffset, "", false);
 
 const getLicenseMockedResponse =
   (licenseType: LicenseType, expiringInDays: number, extensionUrl: string, isExpired: boolean) =>
@@ -48,7 +49,7 @@ const getLicenseMockedResponse =
         licenseExtensionUrl = extensionUrl ? extensionUrl : "https://particular.net/extend-your-trial?p=servicepulse";
         break;
       case LicenseType.UpgradeProtection:
-        status = isExpired ? LicenseStatus.InvalidDueToExpiredUpgradeProtection : LicenseStatus.ValidWithExpiringUpgradeProtection;
+        status = LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported;
         upgradeProtectionExpiration = customISOString;
         licenseExtensionUrl = extensionUrl ? extensionUrl : "https://particular.net/extend-your-trial?p=servicepulse";
         break;