JavaScript Mønstertilpasning med Guard-komposisjon: Mestring av kompleks betinget logikk for globale team

            function processUserAction(user, event, systemConfig) {
  if (user && user.isAuthenticated) {
    if (user.roles.includes('admin') || user.permissions.canEdit) {
      if (event.type === 'UPDATE_ITEM' && event.payload && event.payload.itemId) {
        if (systemConfig.isMaintenanceMode && user.roles.includes('super_admin')) {
          // Tillat super-administratorer å omgå vedlikehold for oppdateringer
          console.log(`Admin ${user.id} updated item ${event.payload.itemId} during maintenance.`);
          return updateItem(event.payload.itemId, event.payload.data);
        } else if (!systemConfig.isMaintenanceMode) {
          console.log(`User ${user.id} updated item ${event.payload.itemId}.`);
          return updateItem(event.payload.itemId, event.payload.data);
        } else {
          console.warn('Cannot update item: System in maintenance mode.');
          return { status: 'error', message: 'Maintenance mode active' };
        }
      } else if (event.type === 'VIEW_DASHBOARD' && user.permissions.canViewDashboard) {
        console.log(`User ${user.id} viewed dashboard.`);
        return getDashboardData(user.id);
      } else {
        console.warn('Unknown or unauthorized event type for this user.');
        return { status: 'error', message: 'Invalid event' };
      }
    } else {
      console.warn('User does not have sufficient permissions.');
      return { status: 'error', message: 'Insufficient permissions' };
    }
  } else {
    console.warn('Unauthorized access: User not authenticated.');
    return { status: 'error', message: 'Authentication required' };
  }
}

            

              
                Copy
              
            
          

            const value = /* noen data */; 

const result = switch (value) {
  case pattern1 => expression1,
  case pattern2 => expression2,
  // ...
  default => defaultExpression,
};

            

              
                Copy
              
            
          

            const event = { type: 'USER_LOGIN', payload: { userId: 'abc' } };

const handlerResult = switch (event) {
  case { type: 'USER_LOGIN', payload: { userId } } => `User ${userId} logged in.`,
  case { type: 'USER_LOGOUT', payload: { userId } } => `User ${userId} logged out.`,
  case { type: 'ERROR', payload: { message } } => `Error: ${message}.`,
  default => 'Unknown event type.'
};

console.log(handlerResult); // Utdata: "User abc logged in."

            

              
                Copy
              
            
          

            const result = switch (value) {
  case pattern if conditionExpression => expression,
  // ...
};

            

              
                Copy
              
            
          

            const user = { id: 'admin1', name: 'Alice', role: 'admin', isActive: true, age: 30 };
const event = { type: 'EDIT_SETTINGS', targetId: 'config1' };

const processingResult = switch ([user, event]) {
  case [{ role: 'admin', isActive: true, age }, { type: 'EDIT_SETTINGS', targetId }] if age > 18 => {
    console.log(`Admin ${user.name} (${user.id}) aged ${age} is editing settings for ${targetId}.`);
    // Utfør logikk for redigering av innstillinger spesifikk for administrator
    return { status: 'success', action: 'EDIT_SETTINGS', entity: targetId };
  },
  case [{ role: 'user' }, { type: 'VIEW_PROFILE', targetId }] => {
    console.log(`User ${user.name} (${user.id}) is viewing profile for ${targetId}.`);
    // Utfør logikk for visning av profil spesifikk for bruker
    return { status: 'success', action: 'VIEW_PROFILE', entity: targetId };
  },
  default => {
    console.warn('No matching pattern or guard condition met.');
    return { status: 'failure', message: 'Action not authorized or recognized' };
  }
};

console.log(processingResult);

// Eksempel 2: Ikke-aktiv administrator
const inactiveUser = { id: 'admin2', name: 'Bob', role: 'admin', isActive: false, age: 45 };
const inactiveResult = switch ([inactiveUser, event]) {
  case [{ role: 'admin', isActive: true, age }, { type: 'EDIT_SETTINGS', targetId }] if age > 18 => {
    console.log(`Admin ${inactiveUser.name} (${inactiveUser.id}) aged ${age} is editing settings for ${targetId}.`);
    return { status: 'success', action: 'EDIT_SETTINGS', entity: targetId };
  },
  default => {
    console.warn('No matching pattern or guard condition met for inactive admin.');
    return { status: 'failure', message: 'Action not authorized or recognized' };
  }
};

console.log(inactiveResult); // Vil treffe default fordi isActive er false

            

              
                Copy
              
            
          

            const order = { 
  id: 'ORD-001', 
  status: 'PENDING', 
  payment: { type: 'CREDIT_CARD', status: 'PAID' }, 
  items: [{ productId: 'P001', quantity: 1 }], 
  shippingAddress: '123 Global St.' 
};
const inventoryService = { 
  check: (id) => id === 'P001' ? { available: 5 } : { available: 0 },
  reserve: (id, qty) => console.log(`Reserved ${qty} of ${id}`), 
  dispatch: (orderId) => console.log(`Dispatched order ${orderId}`)
};
const fraudDetectionService = { 
  isFraudulent: (order) => false 
}; // Anta ingen svindel i dette eksempelet

function processOrder(order, services) {
  return switch (order) {
    // Case 1: Ordren er VENTER, betalingen er BETALT, og lagerbeholdningen er tilgjengelig (kompleks guard)
    case { 
      status: 'PENDING',
      payment: { type: paymentType, status: 'PAID' },
      items: [{ productId, quantity }],
      id: orderId
    } 
    if (paymentType === 'CREDIT_CARD' && services.inventoryService.check(productId).available >= quantity && !services.fraudDetectionService.isFraudulent(order)) => {
      services.inventoryService.reserve(productId, quantity);
      // Simuler utsending
      services.inventoryService.dispatch(orderId);
      console.log(`Order ${orderId} processed and dispatched via ${paymentType}.`);
      return { status: 'SUCCESS', message: 'Order dispatched.' };
    },

    // Case 2: Ordren er VENTER, betalingen er VENTER, krever manuell gjennomgang
    case { status: 'PENDING', payment: { status: 'PENDING' } } => {
      console.log(`Order ${order.id} is pending payment. Requires manual review.`);
      return { status: 'PENDING_PAYMENT', message: 'Payment authorization required.' };
    },

    // Case 3: Ordren er VENTER, men lagerbeholdningen er utilstrekkelig (spesifikt del-tilfelle)
    case { 
      status: 'PENDING',
      items: [{ productId, quantity }],
      id: orderId
    } if (services.inventoryService.check(productId).available < quantity) => {
      console.warn(`Order ${orderId} failed: Insufficient inventory for product ${productId}.`);
      return { status: 'FAILED', message: 'Insufficient inventory.' };
    },

    // Case 4: Ordren er allerede KANSELLERT eller MISLYKKET
    case { status: orderStatus } if (orderStatus === 'CANCELLED' || orderStatus === 'FAILED') => {
      console.log(`Order ${order.id} is already ${orderStatus}. No action taken.`);
      return { status: 'NO_ACTION', message: `Order already ${orderStatus}.` };
    },

    // Standard catch-all
    default => {
      console.warn(`Could not process order ${order.id} due to unhandled state.`);
      return { status: 'UNKNOWN_FAILURE', message: 'Unhandled order state.' };
    }
  };
}

// Testtilfeller:
console.log('\n--- Test Case 1: Successful Order ---');
const result1 = processOrder(order, { inventoryService, fraudDetectionService });
console.log(JSON.stringify(result1, null, 2));

console.log('\n--- Test Case 2: Insufficient Inventory ---');
const order2 = { ...order, items: [{ productId: 'P001', quantity: 10 }] }; // Only 5 available
const result2 = processOrder(order2, { inventoryService, fraudDetectionService });
console.log(JSON.stringify(result2, null, 2));

console.log('\n--- Test Case 3: Pending Payment ---');
const order3 = { ...order, payment: { type: 'BANK_TRANSFER', status: 'PENDING' } };
const result3 = processOrder(order3, { inventoryService, fraudDetectionService });
console.log(JSON.stringify(result3, null, 2));

console.log('\n--- Test Case 4: Cancelled Order ---');
const order4 = { ...order, status: 'CANCELLED' };
const result4 = processOrder(order4, { inventoryService, fraudDetectionService });
console.log(JSON.stringify(result4, null, 2));

            

              
                Copy
              
            
          

            const currentUser = { id: 'usr-456', role: 'editor', permissions: ['edit:article', 'view:analytics'], region: 'EU' };
const actionRequest = { type: 'UPDATE_ARTICLE', articleId: 'art-007', payload: { title: 'New Title' }, region: 'EU' };
const systemStatus = { maintenanceMode: false, readOnlyMode: false, geoRestrictions: { 'US': ['edit:article'] } };

// Hjelpefunksjon for å sjekke globale tillatelser (kunne vært mer sofistikert)
const hasPermission = (user, perm) => user.permissions.includes(perm);

function authorizeAction(user, action, status) {
  return switch ([user, action]) {
    // Prioritet 1: Super-administrator kan gjøre alt, selv i vedlikeholdsmodus, hvis handlingen er for deres region
    case [{ role: 'super_admin', region: userRegion }, { region: actionRegion }] 
    if (userRegion === actionRegion) => {
      console.log(`SUPER ADMIN ${user.id} authorized for action ${action.type} in region ${userRegion}.`);
      return { authorized: true, reason: 'Super Admin privileges.' };
    },

    // Prioritet 2: Administrator kan utføre spesifikke handlinger hvis ikke i skrivebeskyttet modus, og for deres region
    case [{ role: 'admin', region: userRegion }, { type: actionType, region: actionRegion }] 
    if (userRegion === actionRegion && !status.readOnlyMode && (actionType === 'PUBLISH_ARTICLE' || actionType === 'MANAGE_USERS')) => {
      console.log(`ADMIN ${user.id} authorized for ${actionType} in region ${userRegion}.`);
      return { authorized: true, reason: 'Admin role.' };
    },

    // Prioritet 3: Bruker med spesifikk tillatelse for handlingstypen og regionen, ikke i vedlikeholds-/skrivebeskyttet modus
    case [{ permissions, region: userRegion }, { type: actionType, region: actionRegion }] 
    if (userRegion === actionRegion && hasPermission(user, `edit:${actionType.toLowerCase().replace('_article', '')}`) && !status.maintenanceMode && !status.readOnlyMode) => {
      console.log(`USER ${user.id} authorized for ${actionType} in region ${userRegion} via permission.`);
      return { authorized: true, reason: 'Specific permission granted.' };
    },

    // Prioritet 4: Hvis systemet er i vedlikeholdsmodus, avslå alle handlinger fra andre enn super-administratorer
    case _ if status.maintenanceMode => {
      console.warn('Action denied: System is in maintenance mode.');
      return { authorized: false, reason: 'System in maintenance mode.' };
    },

    // Prioritet 5: Hvis skrivebeskyttet modus er aktiv, avslå handlinger som endrer data
    case [{ role }, { type }] if (status.readOnlyMode && (type.startsWith('UPDATE_') || type.startsWith('CREATE_') || type.startsWith('DELETE_'))) => {
      console.warn(`Action denied: Read-only mode active. Cannot ${type}.`);
      return { authorized: false, reason: 'System in read-only mode.' };
    },

    // Standard: Avslå hvis ingen annen spesifikk autorisasjon matchet
    default => {
      console.warn(`Action ${action.type} denied for ${user.id}. No matching authorization rule.`);
      return { authorized: false, reason: 'No matching authorization rule.' };
    }
  };
}

// Testtilfeller:
console.log('\n--- Test Case 1: Editor updates article in same region ---');
let authResult1 = authorizeAction(currentUser, actionRequest, systemStatus);
console.log(JSON.stringify(authResult1, null, 2));

console.log('\n--- Test Case 2: Editor attempts update in different region (denied) ---');
let actionRequest2 = { ...actionRequest, region: 'US' };
let authResult2 = authorizeAction(currentUser, actionRequest2, systemStatus);
console.log(JSON.stringify(authResult2, null, 2));

console.log('\n--- Test Case 3: Admin attempts to publish in maintenance mode (denied by later guard) ---');
let adminUser = { id: 'adm-001', role: 'admin', permissions: ['publish:article'], region: 'EU' };
let publishAction = { type: 'PUBLISH_ARTICLE', articleId: 'art-008', region: 'EU' };
let maintenanceStatus = { ...systemStatus, maintenanceMode: true };
let authResult3 = authorizeAction(adminUser, publishAction, maintenanceStatus);
console.log(JSON.stringify(authResult3, null, 2)); // Bør bli avslått av guard for vedlikeholdsmodus

console.log('\n--- Test Case 4: Super Admin in maintenance mode ---');
let superAdminUser = { id: 'sa-001', role: 'super_admin', permissions: [], region: 'EU' };
let authResult4 = authorizeAction(superAdminUser, publishAction, maintenanceStatus);
console.log(JSON.stringify(authResult4, null, 2)); // Bør bli autorisert

            

              
                Copy
              
            
          

            const featureFlags = { 
  'enableAdvancedReporting': true, 
  'enablePremiumSupport': false, 
  'allowBetaFeatures': true 
};

const userProfile = { 
  id: 'jane-d', 
  subscription: 'premium', 
  region: 'APAC', 
  lastLogin: new Date('2023-10-26T10:00:00Z') 
};

const action = { type: 'GENERATE_REPORT', reportType: 'FINANCIAL' };

// Hjelpefunksjoner for komplekse guard-betingelser
const isPremiumUser = (user) => user.subscription === 'premium';
const isFeatureEnabled = (flagName) => featureFlags[flagName] === true;
const isRegionalAccessAllowed = (userRegion, actionRegion) => userRegion === actionRegion; // Forenklet
const isTimeOfDayValid = (hour) => hour >= 9 && hour <= 17; // 09.00 til 17.00 lokal tid

function handleUserAction(user, userAction) {
  const currentHour = new Date().getUTCHours(); // Eksempel: Bruker UTC-time

  return switch ([user, userAction]) {
    // Case 1: Premium-bruker genererer finansiell rapport, funksjon aktivert, innenfor gyldig tid, i tillatt region
    case [userObj, { type: 'GENERATE_REPORT', reportType: 'FINANCIAL' }] 
    if (isPremiumUser(userObj) && isFeatureEnabled('enableAdvancedReporting') && isTimeOfDayValid(currentHour) && isRegionalAccessAllowed(userObj.region, 'APAC')) => {
      console.log(`Premium user ${userObj.id} generating FINANCIAL report.`);
      return { status: 'SUCCESS', message: 'Financial report initiated.' };
    },

    // Case 2: Enhver bruker ser på basisrapport (funksjon ikke påkrevd), i tillatt region
    case [userObj, { type: 'VIEW_REPORT', reportType: 'BASIC' }] 
    if (isRegionalAccessAllowed(userObj.region, 'GLOBAL')) => { // Antar at basisrapporter er globale
      console.log(`User ${userObj.id} viewing BASIC report.`);
      return { status: 'SUCCESS', message: 'Basic report displayed.' };
    },

    // Case 3: Bruker forsøker premium-støtte, men funksjonen er deaktivert
    case [userObj, { type: 'REQUEST_SUPPORT', supportLevel: 'PREMIUM' }] 
    if (!isFeatureEnabled('enablePremiumSupport')) => {
      console.warn(`User ${userObj.id} requested PREMIUM support, but feature is disabled.`);
      return { status: 'FAILED', message: 'Premium support not available.' };
    },

    // Case 4: Generelt avslag hvis handlingen er utenfor gyldig tidsvindu
    case _ if !isTimeOfDayValid(currentHour) => {
      console.warn('Action denied: Outside operational hours.');
      return { status: 'FAILED', message: 'Service not available at this time.' };
    },

    default => {
      console.warn(`Action ${userAction.type} denied for user ${user.id}.`);
      return { status: 'FAILED', message: 'Action not authorized or recognized.' };
    }
  };
}

// Testtilfeller:
console.log('\n--- Test Case 1: Premium user generating report (should pass if within time) ---');
const result_report = handleUserAction(userProfile, action);
console.log(JSON.stringify(result_report, null, 2));

console.log('\n--- Test Case 2: Attempting disabled premium support ---');
const result_support = handleUserAction(userProfile, { type: 'REQUEST_SUPPORT', supportLevel: 'PREMIUM' });
console.log(JSON.stringify(result_support, null, 2));

// Simuler endring av nåværende time for å teste tidsbasert logikk
const originalGetUTCHours = Date.prototype.getUTCHours;
Date.prototype.getUTCHours = () => 20; // Satt til kl. 20 UTC for testing
console.log('\n--- Test Case 3: Action outside valid time window (simulated) ---');
const result_late = handleUserAction(userProfile, action);
console.log(JSON.stringify(result_late, null, 2));
Date.prototype.getUTCHours = originalGetUTCHours; // Gjenopprett opprinnelig atferd

            

              
                Copy
              
            
          

            if (user && user.isAuthenticated) {
  if (user.roles.includes('admin') || user.permissions.canEdit) {
    if (event.type === 'UPDATE_ITEM' && event.payload && event.payload.itemId) {
      // ... flere betingelser
    }
  }
}

            

              
                Copy
              
            
          

            function processUserActionWithPatternMatching(user, event, systemConfig) {
  return switch ([user, event]) {
    // Admin/Redaktør oppdaterer et element (kompleks guard)
    case [ { isAuthenticated: true, roles, permissions }, 
           { type: 'UPDATE_ITEM', payload: { itemId, data } } ]
    if ((roles.includes('admin') || permissions.canEdit) && 
        (!systemConfig.isMaintenanceMode || (systemConfig.isMaintenanceMode && roles.includes('super_admin')))) => {
      console.log(`User ${user.id} updated item ${itemId}.`);
      return updateItem(itemId, data);
    },

    // Bruker ser på dashbord
    case [ { isAuthenticated: true, permissions }, 
           { type: 'VIEW_DASHBOARD' } ]
    if (permissions.canViewDashboard) => {
      console.log(`User ${user.id} viewed dashboard.`);
      return getDashboardData(user.id);
    },

    // Avslå hvis ikke autentisert (implisitt, da dette er det eneste tilfellet som eksplisitt krever det)
    case [ { isAuthenticated: false }, _ ] => {
        console.warn('Unauthorized access: User not authenticated.');
        return { status: 'error', message: 'Authentication required' };
    },

    // Andre spesifikke avslag / standarder
    default => {
      console.warn('Unknown or unauthorized event type for this user.');
      return { status: 'error', message: 'Invalid event' };
    }
  };
}

            

              
                Copy