Using RapidAPI – on this page: https://rapidapi.com/fvetroo5ri/api/verify-emirates-id

There is a free API that returns the name / address / dob from an emirates ID (think UAE / Dubai / Abu Dhabi), sample code as follows:

https://rapidapi.com/fvetroo5ri/api/verify-emirates-id

curl --request GET \

	--url 'https://verify-emirates-id.p.rapidapi.com/default/EmiratesID?eid=784197600000000' \

	--header 'X-RapidAPI-Host: verify-emirates-id.p.rapidapi.com' \

	--header 'X-RapidAPI-Key: KEY GOES HERE'

and it returns data in the format;

{

  "FirstName": "Mohammed",

  "LastName": "Fatah",

  "DateOfBirth": "1979-05-05",

  "Emirate": "Dubai",

  "Address": "Sheikh Mohammed Bin Rashed Boulevard Downtown Dubai, PO Box 123234 Dubai, UAE"

}

Very nice ... could be useful for KYC: 
 https://rapidapi.com/fvetroo5ri/api/verify-emirates-id

We are excited to announce that our License Plate Lookup API has now extended its services to include support for Tunisia. This latest update brings a valuable tool to the Tunisian market, enabling users to retrieve detailed vehicle information from a license plate number.

Technical Details of the Tunisia Support

Our API, accessible at the endpoint https://www.vehiculeapi.tn/api/reg.asmx?op=CheckTunisia, can now process car registration plates from Tunisia and return comprehensive vehicle details. This enhancement is tailored to meet the specific format of Tunisian license plates.

Understanding Tunisian Plates

Tunisian number plates are unique in their format, reading from right to left. For instance, the letters “TU” represent “تونس”, and “RS” stands for “ت ن”. A sample registration number like “818TU223” could also be interpreted as:

Data Returned by the API

Upon querying a Tunisian license plate, the API will return a wealth of information about the vehicle, including:

• Make / Model: Identifies the brand and model of the car.
• Year: The year of registration.
• Fuel Type: Details the type of fuel the vehicle uses.
• Variant: Specifies the variant of the model.
• Engine Type: Provides information about the engine.
• Representative Image: A URL to an image of the vehicle.

Sample JSON Response

For a better understanding, here’s a sample JSON response for the registration number “818TU223”:

{
  "Description": "Kia PICANTO",
  "RegistrationYear": "2017",
  "RegistrationDate": "01-01-2017",
  "CarMake": {
    "CurrentTextValue": "Kia"
  },
  "CarModel": {
    "CurrentTextValue": "PICANTO"
  },
  "MakeDescription": {
    "CurrentTextValue": "Kia"
  },
  "ModelDescription": {
    "CurrentTextValue": "PICANTO"
  },
  "FuelType": "Essence",
  "Variant": "III (JA) ( 03-2017 > )",
  "Engine": "1.0 67ch ( 03-2017 > ---- ) ",
  "Type": "VOITURE PARTICULIERE",
  "FiscalPower": "0",
  "ImageUrl": "http://www.vehiculeapi.tn/image.aspx/@S2lhIFBJQ0FOVE8="
}

This new feature is a significant step forward in our commitment to providing comprehensive and user-friendly vehicle information services worldwide. It opens up a new avenue for users in Tunisia to easily access detailed vehicle information with just a license plate number.

Stay tuned for more updates and enhancements to our License Plate Lookup API!

Some of this code requires custom-built libraries, so it’s not a great reference, but conceptually, you should be able to see how to use the PayPal REST API in C# using this technique

First, Authentication, you need to get a bearer token before you can all any interesting API endpoints;

        private static string Authenticate(Environment environment)
        {
            var credential = Sandbox;
            if (environment == Environment.LIVE) credential = Live;
            var auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(
                credential.UserName + ":" + credential.Password));
            var http = new HTTPRequest 
            {
                HeaderHandler = h => new NameValueCollection
                {
                    { "Authorization", "Basic " + auth }
                }
            };
            var apiAuthEndpoint = "https://api-m.sandbox.paypal.com/v1/oauth2/token";
            if (environment == Environment.LIVE)
            {
                apiAuthEndpoint = "https://api-m.paypal.com/v1/oauth2/token";
            }
            const string strGrant = "grant_type=client_credentials";
            var authResponse = http.Request(apiAuthEndpoint, "POST", strGrant);
            var jAuthResponse = JObject.Parse(authResponse);
            var token = jAuthResponse["access_token"] + "";
            return token;
        }

Once you have a token, then you can create an order, which in effect gives you a URL to send the user to, and an ID that you should keep for future reference;

            var token = Authenticate(environment);
         
            var intPackageAmount = 100;
            var packageCurrency = "USD";

            var intent = new
            {
                intent = "CAPTURE",
                purchase_units = new[]
                {
                    new
                    {
                        amount = new
                        {
                            currency_code = packageCurrency,
                            value = intPackageAmount
                        }
                    }
                },
                payment_source = new
                {
                    paypal = new
                    {
                        experience_context = new
                        {
                            payment_method_preference = "UNRESTRICTED",
                            landing_page = "LOGIN",
                            user_action = "PAY_NOW",
                            return_url = domain + "/payments/paypalOrderComplete.aspx",
                            cancel_url = domain
                        }
                    }
                }
            };

            var json = JsonConvert.SerializeObject(intent, Formatting.Indented);
            var apiEndpoint = "https://api-m.sandbox.paypal.com/v2/checkout/orders";
            if (environment == Environment.LIVE)
            {
                apiEndpoint = "https://api-m.paypal.com/v2/checkout/orders";
            }
            var http = new HTTPRequest
            {
                HeaderHandler = h => new NameValueCollection
                {
                    { "Authorization", "Bearer " + token }
                },
                ContentType = "application/json"
            };
            var orderSetupJson = http.Request(apiEndpoint, "POST", json);
            var jOrderSetup = JObject.Parse(orderSetupJson);
            var paypalId = jOrderSetup["id"] + "";
            var linksArray = jOrderSetup["links"] as JArray;
            if (linksArray == null) throw new Exception("Paypal Order setup failed");
            var url = "";
            foreach (var link in linksArray)
            {
                if (link["rel"] + "" != "payer-action") continue;
                url = link["href"] + "";
                break;
            }

The Option that said “unrestricted”, helped later on with the capture part.

Once you’ve sent the user to the URL provided by paypal, and it’s returned to your return url, it should also provide you with a token in the Querystring, which matches the id of the order. – I’ve omitted the bit where this is held in a database while the user makes the payment.

Once it comes back, you need to capture the payment as follows;

   // Capture payment
   var apiCaptureEndpoint = "https://api-m.paypal.com/v2/checkout/orders/{0}/capture";
   if (environment == Environment.LIVE)
   {
       apiCaptureEndpoint = "https://api-m.paypal.com/v2/checkout/orders/{0}/capture";
   }
   apiCaptureEndpoint = string.Format(apiCaptureEndpoint, paypalOrderId);
   var captureResponse = http.Request(apiCaptureEndpoint, "POST", "");
   var jCaptureResponse = JObject.Parse(captureResponse);
   status = jCaptureResponse["status"] + "";

Status should be “COMPLETED” after this process is completed, and the money should be transferred.

Test first on sandbox before going live.

Ok, it’s a common task, you’re migrating from one server to another, but you have one website that responds to 100’s of bindings, and you have to move them. Of course you can copy and paste one by one, but here’s a script to do so. It also works with IDN domains.

First, on the source server, run this;

Import-Module WebAdministration

$siteName = "YOUR_SITE.COM"
$exportPath = "C:\TEMP\bindings.csv"

$bindings = Get-WebBinding -Name $siteName | 
            Where-Object { $_.protocol -eq 'http' } | 
            Select-Object protocol, bindingInformation

$bindings | Export-Csv -Path $exportPath -NoTypeInformation -Encoding UTF8

Then, copy the file bindings.csv to the new server, and import them using this

Import-Module WebAdministration

$siteName = "YOUR_SITE.com"
$importPath = "C:\temp\bindings.csv"

$bindings = Import-Csv -Path $importPath -Encoding UTF8

foreach ($binding in $bindings) {
    $protocol = $binding.protocol
    $bindingInformation = $binding.bindingInformation -split ':'
    $ipAddress = $bindingInformation[0]
    $port = $bindingInformation[1]
    $hostHeader = $bindingInformation[2]

    New-WebBinding -Name $siteName -Protocol $protocol -IPAddress $ipAddress -Port $port -HostHeader $hostHeader
}

This doesn’t work for HTTPS domains, since you need to copy the public/private keys as well, and it’s more complex.