refactor(kubernetes): move react codebase [EE-3349] (#7953)

app/react/kubernetes/ingresses/CreateIngressView/utils.ts

@@ -0,0 +1,136 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import { SupportedIngControllerTypes } from '@/react/kubernetes/cluster/ingressClass/types';
+
+import { TLS, Ingress } from '../types';
+
+import { Annotation } from './Annotations/types';
+import { Host, Rule } from './types';
+
+const ignoreAnnotationsForEdit = [
+  'kubectl.kubernetes.io/last-applied-configuration',
+];
+
+export function prepareTLS(hosts: Host[]) {
+  const tls: TLS[] = [];
+  hosts.forEach((host) => {
+    if (host.Secret && host.Host) {
+      tls.push({
+        Hosts: [host.Host],
+        SecretName: host.Secret,
+      });
+    }
+  });
+  return tls;
+}
+
+export function preparePaths(ingressName: string, hosts: Host[]) {
+  return hosts.flatMap((host) =>
+    host.Paths.map((p) => ({
+      ServiceName: p.ServiceName,
+      Host: host.Host,
+      Path: p.Route,
+      Port: p.ServicePort,
+      PathType: p.PathType || 'Prefix',
+      IngressName: ingressName,
+    }))
+  );
+}
+
+export function prepareAnnotations(annotations: Annotation[]) {
+  const result: Record<string, string> = {};
+  annotations.forEach((a) => {
+    result[a.Key] = a.Value;
+  });
+  return result;
+}
+
+function getSecretByHost(host: string, tls?: TLS[]) {
+  let secret = '';
+  if (tls) {
+    tls.forEach((t) => {
+      if (t.Hosts.indexOf(host) !== -1) {
+        secret = t.SecretName;
+      }
+    });
+  }
+  return secret;
+}
+
+export function prepareRuleHostsFromIngress(ing: Ingress) {
+  const hosts = ing.Hosts?.map((host) => {
+    const h: Host = {} as Host;
+    h.Host = host;
+    h.Secret = getSecretByHost(host, ing.TLS);
+    h.Paths = [];
+    ing.Paths?.forEach((path) => {
+      if (path.Host === host) {
+        h.Paths.push({
+          Route: path.Path,
+          ServiceName: path.ServiceName,
+          ServicePort: path.Port,
+          PathType: path.PathType,
+          Key: Math.random().toString(),
+        });
+      }
+    });
+    if (!host) {
+      h.NoHost = true;
+    }
+    h.Key = uuidv4();
+    return h;
+  });
+
+  return hosts;
+}
+
+export function getAnnotationsForEdit(
+  annotations: Record<string, string>
+): Annotation[] {
+  const result: Annotation[] = [];
+  Object.keys(annotations).forEach((k) => {
+    if (ignoreAnnotationsForEdit.indexOf(k) === -1) {
+      result.push({
+        Key: k,
+        Value: annotations[k],
+        ID: uuidv4(),
+      });
+    }
+  });
+  return result;
+}
+
+export function prepareRuleFromIngress(
+  ing: Ingress,
+  type?: SupportedIngControllerTypes
+): Rule {
+  return {
+    Key: uuidv4(),
+    IngressName: ing.Name,
+    Namespace: ing.Namespace,
+    IngressClassName: type === 'custom' ? 'none' : ing.ClassName,
+    Hosts: prepareRuleHostsFromIngress(ing) || [],
+    Annotations: ing.Annotations ? getAnnotationsForEdit(ing.Annotations) : [],
+    IngressType: ing.Type,
+  };
+}
+
+export function checkIfPathExistsWithHost(
+  ingresses: Ingress[],
+  host: string,
+  path: string,
+  ingressName?: string
+) {
+  let exists = false;
+  ingresses.forEach((ingress) => {
+    if (ingressName && ingress.Name === ingressName) {
+      return;
+    }
+    ingress.Paths?.forEach((p) => {
+      if (p.Host === host && p.Path === path) {
+        exists = true;
+      }
+    });
+  });
+  return exists;
+}