Network Programming in .NET

{
  "Description": "RENAULT MEGANE",
  "CarMake": {
    "CurrentTextValue": "RENAULT"
  },
  "CarModel": {
    "CurrentTextValue": "MEGANE"
  },
  "MakeDescription": {
    "CurrentTextValue": "RENAULT"
  },
  "ModelDescription": {
    "CurrentTextValue": "MEGANE"
  },
  "EngineSize": "1461",
  "VehicleIdentificationNumber": null,
  "RegistrationYear": "2010",
  "RegistrationDate": "06/07/2010",
  "Variation": "EXPRESSION 1.5DCI 85",
  "Seats": null,
  "VariantType": "Diesel 1461 cc 5 puertas",
  "VehicleType": "Car",
  "Fuel": "Diesel",
  "IndicativePrice": null,
  "Doors": "5",
  "AllTerain": null,
  "DynamicPower": "85.0",
  "Stolen": null
}

{
  "Description": "SUZUKI DL 650 V-STROM",
  "CarMake": {
    "CurrentTextValue": "SUZUKI"
  },
  "CarModel": {
    "CurrentTextValue": "DL 650"
  },
  "MakeDescription": {
    "CurrentTextValue": "SUZUKI"
  },
  "ModelDescription": {
    "CurrentTextValue": "DL 650"
  },
  "EngineSize": "645",
  "VehicleIdentificationNumber": "",
  "RegistrationYear": "2003",
  "RegistrationDate": "01/11/2003",
  "Variation": "V-STROM",
  "Seats": 1,
  "VariantType": "",
  "VehicleType": "MOTOCICLETA",
  "Fuel": "GASOLINA",
  "IndicativePrice": "7909.79",
  "Doors": 0,
  "AllTerain": 0,
  "KType": 0,
  "Transmission": "MANUAL",
  "DynamicPower": "68",
  "Stolen": null
}

// JavaScript example for Spanish vehicle lookup
class SpanishVehicleAPI {
  constructor(username) {
    this.username = username;
    this.carUrl = "https://www.matriculaapi.com/api/reg.asmx/CheckSpain";
    this.motorcycleUrl = "https://www.matriculaapi.com/api/bespokeapi.asmx/CheckMotorBikeSpain";
  }
  
  async lookupCar(registrationNumber) {
    const apiUrl = `${this.carUrl}?RegistrationNumber=${registrationNumber}&username=${this.username}`;
    
    try {
      const response = await fetch(apiUrl);
      const xmlText = await response.text();
      
      // Parse XML response
      const parser = new DOMParser();
      const xmlDoc = parser.parseFromString(xmlText, "text/xml");
      const jsonData = xmlDoc.getElementsByTagName("vehicleJson")[0].textContent;
      const vehicleInfo = JSON.parse(jsonData);
      
      return {
        type: 'car',
        make: vehicleInfo.MakeDescription.CurrentTextValue,
        model: vehicleInfo.ModelDescription.CurrentTextValue,
        year: vehicleInfo.RegistrationYear,
        registrationDate: vehicleInfo.RegistrationDate,
        engineSize: vehicleInfo.EngineSize,
        fuel: vehicleInfo.Fuel,
        power: vehicleInfo.DynamicPower,
        variant: vehicleInfo.Variation,
        variantType: vehicleInfo.VariantType,
        doors: vehicleInfo.Doors,
        seats: vehicleInfo.Seats,
        vin: vehicleInfo.VehicleIdentificationNumber,
        kType: vehicleInfo.KType,
        stolen: vehicleInfo.Stolen,
        indicativePrice: vehicleInfo.IndicativePrice
      };
    } catch (error) {
      console.error('Spanish car lookup failed:', error);
      return null;
    }
  }
  
  async lookupMotorcycle(registrationNumber) {
    const apiUrl = `${this.motorcycleUrl}?RegistrationNumber=${registrationNumber}&username=${this.username}`;
    
    try {
      const response = await fetch(apiUrl);
      const xmlText = await response.text();
      
      // Parse XML response
      const parser = new DOMParser();
      const xmlDoc = parser.parseFromString(xmlText, "text/xml");
      const jsonData = xmlDoc.getElementsByTagName("vehicleJson")[0].textContent;
      const motorcycleInfo = JSON.parse(jsonData);
      
      return {
        type: 'motorcycle',
        make: motorcycleInfo.MakeDescription.CurrentTextValue,
        model: motorcycleInfo.ModelDescription.CurrentTextValue,
        year: motorcycleInfo.RegistrationYear,
        registrationDate: motorcycleInfo.RegistrationDate,
        engineSize: motorcycleInfo.EngineSize,
        fuel: motorcycleInfo.Fuel,
        power: motorcycleInfo.DynamicPower,
        variant: motorcycleInfo.Variation,
        seats: motorcycleInfo.Seats,
        transmission: motorcycleInfo.Transmission,
        vin: motorcycleInfo.VehicleIdentificationNumber,
        stolen: motorcycleInfo.Stolen,
        indicativePrice: motorcycleInfo.IndicativePrice
      };
    } catch (error) {
      console.error('Spanish motorcycle lookup failed:', error);
      return null;
    }
  }
  
  async lookupWithAutoDetect(registrationNumber) {
    // Try car lookup first
    let result = await this.lookupCar(registrationNumber);
    if (result && result.make) {
      return result;
    }
    
    // If car lookup fails, try motorcycle
    result = await this.lookupMotorcycle(registrationNumber);
    return result;
  }
}

// Usage examples
const api = new SpanishVehicleAPI("your_username");

// Car lookup
api.lookupCar("5428GXS").then(data => {
  if (data) {
    console.log(`Car: ${data.make} ${data.model} (${data.year})`);
    console.log(`Engine: ${data.engineSize}cc ${data.fuel}`);
    console.log(`Power: ${data.power}HP`);
    console.log(`Variant: ${data.variant}`);
    if (data.stolen) {
      console.warn('⚠️ VEHICLE REPORTED STOLEN');
    }
  }
});

// Motorcycle lookup
api.lookupMotorcycle("1234ABC").then(data => {
  if (data) {
    console.log(`Motorcycle: ${data.make} ${data.model} (${data.year})`);
    console.log(`Engine: ${data.engineSize}cc`);
    console.log(`Power: ${data.power}HP`);
    console.log(`Transmission: ${data.transmission}`);
  }
});

// Auto-detect vehicle type
api.lookupWithAutoDetect("5428GXS").then(data => {
  if (data) {
    console.log(`${data.type}: ${data.make} ${data.model}`);
  }
});

import requests
import xml.etree.ElementTree as ET
import json

class SpanishVehicleAPI:
    def __init__(self, username):
        self.username = username
        self.car_url = "https://www.matriculaapi.com/api/reg.asmx/CheckSpain"
        self.motorcycle_url = "https://www.matriculaapi.com/api/bespokeapi.asmx/CheckMotorBikeSpain"
    
    def validate_spanish_registration(self, registration):
        """Validate Spanish registration number format"""
        if not registration:
            return False, "Registration number is required"
        
        # Remove spaces and convert to uppercase
        reg = registration.replace(" ", "").upper()
        
        # Spanish format: 4 numbers + 3 letters (modern format)
        if len(reg) < 6 or len(reg) > 8:
            return False, "Invalid registration length"
        
        return True, reg
    
    def lookup_car(self, registration_number):
        """Lookup Spanish car with comprehensive error handling"""
        is_valid, processed_reg = self.validate_spanish_registration(registration_number)
        if not is_valid:
            return {"error": processed_reg}
        
        try:
            params = {
                'RegistrationNumber': processed_reg,
                'username': self.username
            }
            
            response = requests.get(self.car_url, params=params, timeout=15)
            response.raise_for_status()
            
            # Parse XML response
            root = ET.fromstring(response.content)
            json_element = root.find('.//vehicleJson')
            
            if json_element is None or not json_element.text:
                return {"error": "No car data found for this registration number"}
            
            vehicle_data = json.loads(json_element.text)
            
            return {
                'success': True,
                'type': 'car',
                'description': vehicle_data.get('Description'),
                'make': vehicle_data.get('MakeDescription', {}).get('CurrentTextValue'),
                'model': vehicle_data.get('ModelDescription', {}).get('CurrentTextValue'),
                'registration_year': vehicle_data.get('RegistrationYear'),
                'registration_date': vehicle_data.get('RegistrationDate'),
                'engine_size': vehicle_data.get('EngineSize'),
                'fuel_type': vehicle_data.get('Fuel'),
                'power_hp': vehicle_data.get('DynamicPower'),
                'variant': vehicle_data.get('Variation'),
                'variant_type': vehicle_data.get('VariantType'),
                'doors': vehicle_data.get('Doors'),
                'seats': vehicle_data.get('Seats'),
                'vin': vehicle_data.get('VehicleIdentificationNumber'),
                'k_type': vehicle_data.get('KType'),
                'stolen': vehicle_data.get('Stolen'),
                'indicative_price': vehicle_data.get('IndicativePrice'),
                'all_terrain': vehicle_data.get('AllTerain'),
                'raw_data': vehicle_data
            }
            
        except Exception as e:
            return {"error": f"Car lookup failed: {str(e)}"}
    
    def lookup_motorcycle(self, registration_number):
        """Lookup Spanish motorcycle"""
        is_valid, processed_reg = self.validate_spanish_registration(registration_number)
        if not is_valid:
            return {"error": processed_reg}
        
        try:
            params = {
                'RegistrationNumber': processed_reg,
                'username': self.username
            }
            
            response = requests.get(self.motorcycle_url, params=params, timeout=15)
            response.raise_for_status()
            
            # Parse XML response
            root = ET.fromstring(response.content)
            json_element = root.find('.//vehicleJson')
            
            if json_element is None or not json_element.text:
                return {"error": "No motorcycle data found for this registration number"}
            
            motorcycle_data = json.loads(json_element.text)
            
            return {
                'success': True,
                'type': 'motorcycle',
                'description': motorcycle_data.get('Description'),
                'make': motorcycle_data.get('MakeDescription', {}).get('CurrentTextValue'),
                'model': motorcycle_data.get('ModelDescription', {}).get('CurrentTextValue'),
                'registration_year': motorcycle_data.get('RegistrationYear'),
                'registration_date': motorcycle_data.get('RegistrationDate'),
                'engine_size': motorcycle_data.get('EngineSize'),
                'fuel_type': motorcycle_data.get('Fuel'),
                'power_hp': motorcycle_data.get('DynamicPower'),
                'variant': motorcycle_data.get('Variation'),
                'seats': motorcycle_data.get('Seats'),
                'transmission': motorcycle_data.get('Transmission'),
                'vin': motorcycle_data.get('VehicleIdentificationNumber'),
                'stolen': motorcycle_data.get('Stolen'),
                'indicative_price': motorcycle_data.get('IndicativePrice'),
                'raw_data': motorcycle_data
            }
            
        except Exception as e:
            return {"error": f"Motorcycle lookup failed: {str(e)}"}
    
    def lookup_with_auto_detect(self, registration_number):
        """Try both car and motorcycle endpoints automatically"""
        # Try car first
        result = self.lookup_car(registration_number)
        if result.get('success'):
            return result
        
        # Try motorcycle if car lookup fails
        result = self.lookup_motorcycle(registration_number)
        if result.get('success'):
            return result
        
        return {"error": "Vehicle not found in car or motorcycle databases"}

# Usage examples
api = SpanishVehicleAPI("your_username")

# Car lookup
car_result = api.lookup_car("5428GXS")
if car_result.get('success'):
    print(f"Car: {car_result['make']} {car_result['model']}")
    print(f"Year: {car_result['registration_year']}")
    print(f"Engine: {car_result['engine_size']}cc {car_result['fuel_type']}")
    print(f"Power: {car_result['power_hp']}HP")
    print(f"Variant: {car_result['variant']}")
    
    if car_result['stolen']:
        print("⚠️ WARNING: VEHICLE REPORTED STOLEN")

# Motorcycle lookup
bike_result = api.lookup_motorcycle("1234ABC")
if bike_result.get('success'):
    print(f"Motorcycle: {bike_result['make']} {bike_result['model']}")
    print(f"Engine: {bike_result['engine_size']}cc")
    print(f"Power: {bike_result['power_hp']}HP")
    print(f"Transmission: {bike_result['transmission']}")

# Auto-detect vehicle type
auto_result = api.lookup_with_auto_detect("5428GXS")
if auto_result.get('success'):
    print(f"Vehicle Type: {auto_result['type']}")
    print(f"Vehicle: {auto_result['make']} {auto_result['model']}")

class SecureSpanishVehicleAPI extends SpanishVehicleAPI {
  constructor(username) {
    super(username);
    this.maxRetries = 3;
    this.retryDelay = 1000; // milliseconds
  }
  
  async lookupWithSecurity(registrationNumber, vehicleType = 'auto') {
    // Validate input to prevent injection
    if (!this.validateInput(registrationNumber)) {
      return {
        error: true,
        message: "Invalid registration format",
        security: "Input validation failed"
      };
    }
    
    // Perform lookup with retry logic
    let lastError;
    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        let result;
        
        if (vehicleType === 'car') {
          result = await this.lookupCar(registrationNumber);
        } else if (vehicleType === 'motorcycle') {
          result = await this.lookupMotorcycle(registrationNumber);
        } else {
          result = await this.lookupWithAutoDetect(registrationNumber);
        }
        
        // Check for stolen vehicle
        if (result && result.stolen) {
          console.warn(`SECURITY ALERT: Vehicle ${registrationNumber} reported stolen`);
          result.securityAlert = "STOLEN_VEHICLE";
        }
        
        return result;
        
      } catch (error) {
        lastError = error;
        
        if (attempt < this.maxRetries) {
          await new Promise(resolve => 
            setTimeout(resolve, this.retryDelay * attempt)
          );
        }
      }
    }
    
    return {
      error: true,
      message: `Lookup failed after ${this.maxRetries} attempts`,
      details: lastError.message
    };
  }
  
  validateInput(registration) {
    // Prevent SQL injection and XSS
    if (!registration || typeof registration !== 'string') {
      return false;
    }
    
    // Check for suspicious characters
    const suspiciousPattern = /[;<>'"\\]/;
    if (suspiciousPattern.test(registration)) {
      return false;
    }
    
    return true;
  }
}