部落格

graph LR
    A[Full Number (E.164)] --> B[Country Code (+254)]
    A --> C[National Significant Number (NSN - 9 digits)]
    C --> D[National Destination Code (NDC - 2 or 3 digits)]
    C --> E[Subscriber Number (SN - 6 or 7 digits)]
    D --> F[Landline (2 digits)]
    D --> G[Mobile (3 digits)]

Format: 0[Area Code][Subscriber Number]
Example: 020 1234567
         │  └─ Subscriber Number (7 digits)
         └──── Area Code (2 digits)

function validateKenyanMobile(number) {
  const regex = /^0[17][0-9]{8}$/; // Updated regex to include prefixes starting with 1
  const prefixRanges = {
    safaricom: /^0[17][0-9]{2}/, // Updated to include prefixes starting with 1
    airtel: /^073[0-9]/,
    telkom: /^077[0-9]/,
    equitel: /^0763[0-9]{2}/ // Added Equitel
  };
  
  return {
    isValid: regex.test(number),
    carrier: determineCarrier(number, prefixRanges)
  };

  function determineCarrier(number, prefixRanges) {
    for (const carrier in prefixRanges) {
      if (prefixRanges[carrier].test(number)) {
        return carrier;
      }
    }
    return 'unknown';
  }
}

// Example test cases
console.log(validateKenyanMobile('0722123456')); // Safaricom, valid
console.log(validateKenyanMobile('0110123456')); // Safaricom, valid (new prefix)
console.log(validateKenyanMobile('0730123456')); // Airtel, valid
console.log(validateKenyanMobile('0770123456')); // Telkom, valid
console.log(validateKenyanMobile('0763123456')); // Equitel, valid
console.log(validateKenyanMobile('0700123456')); // Unknown, valid (could be a new operator)
console.log(validateKenyanMobile('072212345'));  // Invalid (too short)
console.log(validateKenyanMobile('0800123456')); // Invalid (not a mobile prefix)

def check_ported_number(msisdn):
    # Connect to MNP database (replace with actual connection details)
    mnp_db = MNPDatabase.connect(db_host='mnp_db_host', db_user='mnp_user', db_password='mnp_password')
    
    try:
        # Query current carrier
        current_carrier = mnp_db.query_carrier(msisdn)
        
        # Check porting status
        porting_status = mnp_db.get_porting_status(msisdn)
        
        return {
            'original_carrier': determine_original_carrier(msisdn),
            'current_carrier': current_carrier,
            'is_ported': porting_status.is_ported,
            'port_date': porting_status.port_date
        }
    except (ConnectionError, DatabaseError) as e:
        # Handle database connection or query errors
        logger.error(f"MNP database error: {e}")
        # Implement fallback mechanism (e.g., assume original carrier)
        return {'original_carrier': determine_original_carrier(msisdn), 'current_carrier': None, 'is_ported': False, 'port_date': None}
    finally:
        mnp_db.close() # Close the database connection

def determine_original_carrier(msisdn):
    # Logic to determine original carrier based on prefix (before porting)
    # ... (similar to the JavaScript example)
    pass

┌────────────────┐     ┌─────────────────┐     ┌────────────────┐
│ Your Database │ ◀──Synchronization── │ MNP Central DB  │ ──▶ │ Carrier Systems │
└────────────────┘     └─────────────────┘     └────────────────┘

const EMERGENCY_NUMBERS = {
  GENERAL: '999',
  ALTERNATIVE: '112', // Added alternative emergency number
  POLICE: '911',     // Added police emergency number
  FIRE: '990',       // Added fire emergency number
  AMBULANCE: '991'   // Added ambulance emergency number
};

function handleEmergencyCall(number) {
  if (Object.values(EMERGENCY_NUMBERS).includes(number)) {
    // Priority routing
    // Bypass credit checks
    // Enable location services (if applicable)
    console.log(`Routing emergency call to ${number}`);
    return true;
  }
  console.log(`Number ${number} is not an emergency number`);
  return false;
}

// Example test cases
handleEmergencyCall('999');      // Routes emergency call
handleEmergencyCall('112');      // Routes emergency call
handleEmergencyCall('911');      // Routes emergency call
handleEmergencyCall('990');      // Routes emergency call
handleEmergencyCall('991');      // Routes emergency call
handleEmergencyCall('0722123456'); // Not an emergency number

function toInternationalFormat(localNumber) {
  // Remove leading zero and any spaces or hyphens
  const normalized = localNumber.replace(/^0/, '').replace(/[\s-]/g, '');
  // Add country code
  return `+254${normalized}`;
}

// Example test cases
console.log(toInternationalFormat('0722 123 456')); // +254722123456
console.log(toInternationalFormat('020-1234567')); // +254201234567

const validationPatterns = {
  landline: /^0(20|41|[4-6][0-9])[0-9]{7}$/,
  mobile: /^0[17][0-9]{8}$/, // Updated to include prefixes starting with 1
  tollFree: /^0800[0-9]{6}$/,
  premium: /^0900[0-9]{6}$/
};

function validateNumber(number, type) {
  if (!validationPatterns[type]) {
    return false; // Invalid type
  }
  return validationPatterns[type].test(number);
}

// Example test cases
console.log(validateNumber('0201234567', 'landline')); // True
console.log(validateNumber('0722123456', 'mobile'));   // True
console.log(validateNumber('0110123456', 'mobile'));   // True (new prefix)
console.log(validateNumber('0800123456', 'tollFree')); // True
console.log(validateNumber('0900123456', 'premium'));  // True
console.log(validateNumber('072212345', 'mobile'));    // False (too short)
console.log(validateNumber('0201234567', 'mobile'));   // False (wrong type)

interface TuvaluPhoneNumber {
  countryCode: '+688';
  subscriberNumber: string; // 5 digits
  prefix: '2' | '7' | '9'; // Indicates service type
}

// Validation regex for different number types
const validators = {
  landline: /^2\d{4}$/,
  mobile: /^7\d{4}$/,
  premium: /^9\d{4}$/,
  international: /^\+688[279]\d{4}$/
};

function validateTuvaluNumber(number: string, type: keyof typeof validators): boolean {
  // Remove non-digit characters before validation
  const cleanedNumber = number.replace(/\D/g, '');
  return validators[type].test(cleanedNumber);
}

// Example usage:
console.log(validateTuvaluNumber('+68871234', 'international')); // true
console.log(validateTuvaluNumber('21234', 'landline')); // true
console.log(validateTuvaluNumber('712345', 'mobile')); // false (incorrect length)

function formatTuvaluNumber(number: string): string {
  const cleaned = number.replace(/\D/g, '');
  if (cleaned.length !== 5) {
    throw new Error('Invalid number length. Tuvalu subscriber numbers should be 5 digits.');
  }
  return `+688${cleaned}`;
}

// Example usage
console.log(formatTuvaluNumber('21234')); // +68821234

CREATE TABLE phone_numbers (
  id SERIAL PRIMARY KEY,
  raw_number VARCHAR(5) NOT NULL,  -- Store the 5-digit subscriber number
  formatted_number VARCHAR(9) NOT NULL, -- Store the formatted international number
  number_type ENUM('landline', 'mobile', 'premium')
);

// Validate Tristan da Cunha phone numbers
function validateTristanNumber(phoneNumber) {
  // Uses a regular expression to ensure the number starts with +290 and is followed by exactly four digits.
  const regex = /^\+290(8\d{3})$/; 
  return regex.test(phoneNumber);
}

// Example usage
console.log(validateTristanNumber('+2908234')); // true - Valid number within the allocated range
console.log(validateTristanNumber('+2908999')); // true - Valid number at the upper end of the range
console.log(validateTristanNumber('+2907234')); // false - Invalid prefix, outside the 8XXX range
console.log(validateTristanNumber('+2908000')); // true - Valid number at the lower end of the range
console.log(validateTristanNumber('+29081234')); // false - Too many digits
console.log(validateTristanNumber('2908123')); // false - Missing + sign

def format_tristan_number(number):
    """Formats a Tristan da Cunha phone number to international standards.

    Args:
        number (str): The raw phone number.

    Returns:
        str: The formatted phone number, or raises a ValueError if the format is invalid.
    """
    clean_number = ''.join(filter(str.isdigit, number))
    if len(clean_number) == 4 and clean_number.startswith('8'): # Local format
        return f'+290{clean_number}'
    elif len(clean_number) == 7 and clean_number.startswith('2908'): # International format without +
        return f'+{clean_number}'
    elif len(clean_number) == 8 and clean_number.startswith('+2908'): # International format with +
        return clean_number
    else:
        raise ValueError('Invalid Tristan da Cunha phone number format')
# Example usage
print(format_tristan_number("8123")) # Output: +2908123
print(format_tristan_number("+2908123")) # Output: +2908123
print(format_tristan_number("2908123")) # Output: +2908123
try:
    print(format_tristan_number("1234567")) # Raises ValueError
except ValueError as e:
    print(e)

// Landline validation
const landlinePattern = /^22[2-4][2-9]\d{4}$/;

// Mobile number validation
const mobilePattern = /^(25|3[0-5]|66|7[2-9]|8[08]|9[09])\d{6}$/; // Optimized regex

// Example usage
function validateSierraLeoneNumber(phoneNumber) {
    return landlinePattern.test(phoneNumber) || 
           mobilePattern.test(phoneNumber);
}

// Example test cases
console.log(validateSierraLeoneNumber('2222442934')); // true (landline)
console.log(validateSierraLeoneNumber('3098765432')); // true (mobile)
console.log(validateSierraLeoneNumber('112')); // false (special service, not covered by these regex)
console.log(validateSierraLeoneNumber('22123456')); // false (invalid landline)
console.log(validateSierraLeoneNumber('981234567')); // false (invalid mobile)

// Convert to E.164 format
function toE164(localNumber) {
  return '+232' + localNumber.replace(/^0+/, ''); // Remove leading zeros
}

// Example usage
const localNumber = '076123456';
const e164Number = toE164(localNumber); // +23276123456
console.log(e164Number);

function processSierraLeoneNumber(number) {
    // 1. Remove spaces and special characters
    const cleaned = number.replace(/[\s-]/g, '');

    // 2. Validate format
    if (!validateSierraLeoneNumber(cleaned)) {
        throw new Error('Invalid Sierra Leone number format');
    }

    // 3. Convert to E.164
    return toE164(cleaned);
}

// Example usage and error handling
try {
  const processedNumber = processSierraLeoneNumber(' 076 123 456 ');
  console.log(processedNumber); // +23276123456
} catch (error) {
  console.error(error.message);
}

// Fixed-line validation
const fixedLineRegex = /^[2-6]\d{6}$/;

// Mobile number validation
const mobileRegex = /^7\d{7}$/;

// Comprehensive validation function (including country code handling)
function validateMicronesianNumber(number) {
  const cleanedNumber = number.replace(/\D/g, ''); // Remove non-digit characters
  if (cleanedNumber.startsWith('691')) {
      return fixedLineRegex.test(cleanedNumber.slice(3)) || mobileRegex.test(cleanedNumber.slice(3));
  } else {
      return fixedLineRegex.test(cleanedNumber) || mobileRegex.test(cleanedNumber);
  }
}

class MicronesianNumberValidator {
  // ... (same code as original article)
}

// ... (same error handling code as original article)