address pr comments

Author: aalves08

pkg/elemental/components/BuildMedia.vue

@@ -4,7 +4,7 @@ import { Banner } from '@components/Banner';
 import AsyncButton from '@shell/components/AsyncButton';
 import { randomStr, CHARSET } from '@shell/utils/string';
 import { ELEMENTAL_SCHEMA_IDS } from '../config/elemental-types';
-import { semverVersionCheck, getOperatorVersion, getGatedFeature, BUILD_MEDIA_RAW_SUPPORT } from '../utils/feature-versioning';
+import { getOperatorVersion, checkGatedFeatureCompatibility, BUILD_MEDIA_RAW_SUPPORT } from '../utils/feature-versioning';
 
 const MEDIA_TYPES = {
   RAW: {
@@ -54,17 +54,13 @@ export default {
     this.managedOsVersions = await this.$store.dispatch('management/findAll', { type: ELEMENTAL_SCHEMA_IDS.MANAGED_OS_VERSIONS });
 
     this.operatorVersion = await getOperatorVersion(this.$store);
-    this.gatedFeature = getGatedFeature(this.resource, this.mode, BUILD_MEDIA_RAW_SUPPORT);
-    this.buildMediaGatingVersion = this.gatedFeature?.minOperatorVersion || '';
   },
   data() {
     return {
       seedImagesList:               [],
       managedOsVersions:            [],
       filteredManagedOsVersions:    [],
       operatorVersion:              '',
-      gatedFeature:                 {},
-      buildMediaGatingVersion:      '',
       buildMediaOsVersions:         [],
       buildMediaTypes:              [
         { label: MEDIA_TYPES.ISO.label, value: MEDIA_TYPES.ISO.type },
@@ -96,17 +92,13 @@ export default {
   },
   computed: {
     isRawDiskImageBuildSupported() {
-      if (this.operatorVersion && this.buildMediaGatingVersion) {
-        const check = semverVersionCheck(this.operatorVersion, this.buildMediaGatingVersion);
+      const check = checkGatedFeatureCompatibility(this.resource, this.mode, BUILD_MEDIA_RAW_SUPPORT, this.operatorVersion);
 
-        if (!check) {
-          this.buildMediaTypeSelected = MEDIA_TYPES.ISO.type; // eslint-disable-line vue/no-side-effects-in-computed-properties
-        }
-
-        return check;
+      if (!check) {
+        this.buildMediaTypeSelected = MEDIA_TYPES.ISO.type; // eslint-disable-line vue/no-side-effects-in-computed-properties
       }
 
-      return false;
+      return check;
     },
     registrationEndpointsOptions() {
       const activeRegEndpoints = this.registrationEndpointList.filter(item => item.state === 'active');

pkg/elemental/edit/elemental.cattle.io.machineregistration.vue

@@ -16,7 +16,7 @@ import { exceptionToErrorsArray } from '@shell/utils/error';
 import Tabbed from '@shell/components/Tabbed/index.vue';
 import Tab from '@shell/components/Tabbed/Tab.vue';
 
-import { semverVersionCheck, getOperatorVersion, getGatedFeature, MACH_REG_CONFIG_DEFAULTS } from '../utils/feature-versioning';
+import { getOperatorVersion, checkGatedFeatureCompatibility, MACH_REG_CONFIG_DEFAULTS } from '../utils/feature-versioning';
 import { OLD_DEFAULT_CREATION_YAML, DEFAULT_CREATION_YAML } from '../models/elemental.cattle.io.machineregistration';
 
 export default {
@@ -51,10 +51,8 @@ export default {
     // in CREATE mode, since YAMLEditor doesn't live update, we need to force a re-render of the component for it to update
     if (this.mode === _CREATE) {
       const operatorVersion = await getOperatorVersion(this.$store);
-      const gatedFeature = getGatedFeature(this.resource, this.mode, MACH_REG_CONFIG_DEFAULTS);
-      const minOperatorVersion = gatedFeature?.minOperatorVersion || '';
 
-      this.newCloudConfigcompatibilityCheck = semverVersionCheck(operatorVersion, minOperatorVersion);
+      this.newCloudConfigcompatibilityCheck = checkGatedFeatureCompatibility(this.resource, this.mode, MACH_REG_CONFIG_DEFAULTS, operatorVersion);
 
       if (!this.value.spec) {
         this.value.spec = this.newCloudConfigcompatibilityCheck ? DEFAULT_CREATION_YAML : OLD_DEFAULT_CREATION_YAML;
@@ -70,8 +68,7 @@ export default {
       cloudConfig:                      typeof this.value.spec === 'string' ? this.value.spec : saferDump(this.value.spec),
       newCloudConfigcompatibilityCheck: false,
       yamlErrors:                       null,
-      isFormValid:                      true,
-      gatedFeature:                     {}
+      isFormValid:                      true
     };
   },
   watch: {

pkg/elemental/utils/feature-versioning.ts

@@ -12,6 +12,7 @@ interface FeaturesGatingConfig {
   features: string[],
 }
 
+// features to be gated to specific operator versions
 export const MACH_REG_CONFIG_DEFAULTS:string = 'machine-reg-config-defaults';
 export const BUILD_MEDIA_RAW_SUPPORT:string = 'build-media-raw-support';
 
@@ -38,8 +39,7 @@ const FEATURES_GATING:FeaturesGatingConfig[] = [
 
 /**
  * Get the current elemental-operator version
- * @param any store
- * @param any alreadyInstalledApps
+ * @param any Vue store
  * @returns Promise<string | void>
  */
 export async function getOperatorVersion(store: any): Promise<string | void> {
@@ -54,26 +54,23 @@ export async function getOperatorVersion(store: any): Promise<string | void> {
 }
 
 /**
- * Get the gated feature based on resource + mode + string
- * @param string
- * @param string
- * @param string
- * @returns FeaturesGatingConfig | {} | void
+ * Check the gated feature compatibility with the current Elemental Operator version installed
+ * @param string resource type (ex: Deployment)
+ * @param string UI mode (ex: edit, create, view)
+ * @param string Elemental feature (ex: Build media, cloud config)
+ * @param string Elemental Operator version
+ * @returns Boolean
  */
-export function getGatedFeature(resource: string, mode: string, feature: string): FeaturesGatingConfig | {} | void {
-  if (resource && mode) {
-    return FEATURES_GATING.find(feat => feat.area === resource && feat.mode.includes(mode) && feat.features.includes(feature));
-  }
+export function checkGatedFeatureCompatibility(resource: string, mode: string, feature: string, operatorVersion: string): Boolean {
+  if (resource && mode && feature) {
+    const gatedFeature = FEATURES_GATING.find(feat => feat.area === resource && feat.mode.includes(mode) && feat.features.includes(feature));
 
-  return {};
-}
+    if (!gatedFeature?.minOperatorVersion || !operatorVersion) {
+      return false;
+    }
 
-/**
- * Determines if a given feature is enabled by doing a semver version comparison
- * @param string
- * @param string
- * @returns Boolean | void
- */
-export function semverVersionCheck(operatorVersion: string, operatorMinVersion: string): Boolean | void {
-  return semver.gte(operatorVersion, operatorMinVersion);
+    return semver.gte(operatorVersion, gatedFeature?.minOperatorVersion);
+  }
+
+  return false;
 }