Authentication Configuration

• File: src/pages/private/admin/authConfig/index.svelte

Overview

The Authentication Configuration page allows administrators to manage security rules and password policies for the system. It provides a comprehensive interface for configuring brute force detection, password requirements, and account security settings.

Data Structures

Security Policy Interface

interface SecurityPolicy {
  // Brute Force Settings
  enableBruteForce: boolean;
  permanentLockout: boolean;
  maxLoginFailures: number;
  waitIncrement: number;
  waitIncrementStatus: string;
  quickLoginCheck: number;
  quickLoginCheckStatus: string;
  minimumQuickLogin: number;
  minimumQuickLoginStatus: string;
  maxWait: number;
  maxWaitStatus: string;
  failureResetTime: number;
  failureResetTimeStatus: string;

  // Password Policy Settings
  minLength: number;
  daysExpiry: number;
  inactiveDays: number;
  specialCharacters: number;
  upperCase: number;
  lowerCase: number;
}

Core Functions

1. Time Conversion Utilities

// Convert seconds to human-readable format
function convertFromSeconds(valueInSeconds) {
  if (valueInSeconds % 3600 === 0) {
    return {
      convertedValue: valueInSeconds / 3600,
      type: "Hours"
    };
  }
  if (valueInSeconds % 60 === 0) {
    return {
      convertedValue: valueInSeconds / 60,
      type: "Minutes"
    };
  }
  return {
    convertedValue: valueInSeconds,
    type: "Seconds"
  };
}

// Convert human-readable format to seconds
function convertToSeconds(value, type) {
  switch (type) {
    case "Minutes":
      return value * 60;
    case "Hours":
      return value * 3600;
    case "Seconds":
    default:
      return value;
  }
}

2. API Operations

// Save authentication configuration
async function saveAuthConfig(command) {
  const query = `
    mutation SendData ($input: UpdateTenantSecurityRulesCommandInput!) {
      updateTenantSecurityRules(command: $input) {
        success, message, code
      }
    }
  `;

  const { data, error } = await mutation<any>(query, { input: command });
  if (error) {
    showError(error.message);
  }
  return data;
}

// Read current configuration
async function readValues() {
  const { data, error } = await query<any>(`
    query {
      tenantSecurityRules {
        success, message, data {
          daysExpiry, enableBruteForce, failureResetTime,
          inactiveDays, lowerCase, maxLoginFailures,
          maxWait, minimumQuickLogin, minLength,
          permanentLockout, quickLoginCheck,
          specialCharacters, upperCase, waitIncrement
        }
      }
    }
  `);

  if (error) {
    return { success: false, message: error?.message || error };
  }
  return data.tenantSecurityRules;
}

Event Handlers

1. Save Operation

async function onSave() {
  const data = {
    waitIncrement: policy?.waitIncrement
      ? convertToSeconds(policy.waitIncrement, policy.waitIncrementStatus)
      : 0,
    maxWait: policy?.maxWait
      ? convertToSeconds(policy.maxWait, policy.maxWaitStatus)
      : 0,
    failureResetTime: policy?.failureResetTime
      ? convertToSeconds(policy.failureResetTime, policy.failureResetTimeStatus)
      : 0,
    enableBruteForce: policy.enableBruteForce,
    permanentLockout: policy.permanentLockout,
    maxLoginFailures: policy.maxLoginFailures,
    quickLoginCheck: convertToSeconds(
      policy.quickLoginCheck,
      policy.quickLoginCheckStatus
    ),
    minimumQuickLogin: convertToSeconds(
      policy.minimumQuickLogin,
      policy.minimumQuickLoginStatus
    ),
    minLength: policy.minLength,
    daysExpiry: policy.daysExpiry,
    inactiveDays: policy.inactiveDays,
    specialCharacters: policy.specialCharacters,
    upperCase: policy.upperCase,
    lowerCase: policy.lowerCase,
  };

  await toast.promise(saveAuthConfig(data), {
    loading: "Loading...",
    success: (ret: any) => {
      if (!ret?.updateTenantSecurityRules?.success) {
        return ret.message || "Failed";
      }
      return ret?.updateTenantSecurityRules?.message || "Record added";
    },
    error: (error: any) => {
      const errorMessage = error?.message || error;
      return `Error: ${errorMessage}`;
    },
  });
}

UI Implementation

<div class="">
  {#if busy}
    <Progress step={1} />
  {:else}
    <form class="space-y-8 sm:space-y-5" on:submit|preventDefault={onSave}>
      <!-- Brute Force Section -->
      <div class="space-y-5">
        <p class="font-semibold">Brute Force Detection</p>
        <!-- Brute Force Controls -->
      </div>

      <!-- Password Policy Section -->
      <div class="pt-4">
        <p class="font-semibold">Password Policy</p>
        <!-- Password Policy Controls -->
      </div>

      <!-- Save Button -->
      <div class="flex">
        <button
          class="mx-auto border p-2 w-32 bg-slate-100 hover:bg-slate-200"
          type="submit"
        >
          Save
        </button>
      </div>
    </form>
  {/if}
</div>