Biblioteki SDK Dla Kalkulatora Kodów Do Radia

Biblioteki programistyczne SDK dla PHP, Python, JavaScript, C#, Rust, Go, Java, PowerShell i Ruby kalkulatora kodów odblokowujących radioodtwarzacze w samochodach.

Opis

Aby skorzystać ze wszystkich funkcji Kalkulatora Kodów Do Radia API, użyj gotowych pakietów SDK dla swojego języka programowania.

Usługa Web API bazuje na prostym zapytaniu POST i odpowiedzi zakodowanej w postaci JSON.

Te same funkcje są dostępne także przez interfejs REST. GET /api/radio-code-calculator/v1/license sprawdza klucz aktywacyjny. GET /api/radio-code-calculator/v1/radios wymienia obsługiwane modele. GET /api/radio-code-calculator/v1/radios/{model} zwraca limity jednego modelu. POST /api/radio-code-calculator/v1/codes wylicza kod z pól radio_model, serial i extra. GET /api/radio-code-calculator/v1/stats zwraca liczniki użyć. Klucz przekaż w nagłówku Authorization: Bearer albo X-Api-Key. Te wywołania zwracają JSON.

Instalacja

W celu szybszego wdrożenia, paczki instalacyjne interfejsu Web API zostały wgrane na popularne repozytoria (Packagist, PyPI, npm, crates.io, NuGet, pkg.go.dev, Maven, PowerShell Gallery, RubyGems), a ich kody źródłowe zostały dodatkowo opublikowane na GitHubie:

Język Instalacja SDK Źródła
Język programowania PHP

Uruchom komendę:

php composer.phar require --prefer-dist pelock/radio-code-calculator "*"

lub dodaj do sekcji require w pliku konfiguracyjnym composer.json wpis:

"pelock/radio-code-calculator": "*"
Packagist GitHub
Język programowania Python pip install radio-code-calculator PyPI GitHub
Język programowania JavaScript

Uruchom komendę:

npm i radio-code-calculator

lub dodaj do sekcji dependencies w pliku konfiguracyjnym package.json wpis:

"dependencies": {
  "radio-code-calculator": "latest"
},

npm GitHub
Rust / Cargo

Uruchom komendę:

cargo add radio-code-calculator

lub dodaj wpis do sekcji [dependencies] w pliku Cargo.toml:

[dependencies]
radio-code-calculator = "1.0.0"
Crates GitHub
Repozytorium NuGet

Uruchom komendę:

dotnet add package RadioCodeCalculator

lub dodaj do pliku .csproj:

<PackageReference Include="RadioCodeCalculator" Version="1.0.1" />
NuGet GitHub
Pakiety modułów Go

Uruchom komendę:

go get github.com/PELock/Radio-Code-Calculator-Go

lub dodaj poniższy wpis do pliku go.mod

require github.com/PELock/Radio-Code-Calculator-Go v1.1.6
Go GitHub
Centralne Repozytorium Maven Dodaj tę zależność do pliku pom.xml
<dependency>
  <groupId>com.pelock</groupId>
  <artifactId>radio-code-calculator</artifactId>
  <version>1.1.6</version>
</dependency>
Maven GitHub
PowerShell Gallery

Uruchom komendę:

Install-Module -Name RadioCodeCalculator

lub:

Install-PSResource -Name RadioCodeCalculator

PowerShell Gallery GitHub
Repozytorium RubyGems

Uruchom komendę:

gem install radio-code-calculator

lub dodaj poniższy wpis do pliku Gemfile

gem "radio-code-calculator"
RubyGems GitHub

Formaty danych wejściowych

Każdy kalkulator wymaga innego formatu danych wejściowych, takich jak numer seryjny radia, aby poprawnie wygenerować kod odblokowujący. W przypadku podania błędnego formatu danych nie będzie możliwe wygenerowanie kodu odblokowującego.

Formaty danych są weryfikowane w bibliotece programistycznej w trybie online oraz opcjonalnie w trybie offline. Poniżej prezentujemy wymagane formaty dla danych wejściowych:

Model Opis Długość RegEx (PCRE)
Renault i Dacia Kalkulator i Generator Kodu RadiaRenault i Dacia PreCode, gdzie pierwszy znak to zawsze litera A..Z, a po niej występują trzy cyfry 0..9. 4 /^([A-Z]{1}[0-9]{3})$/
Ford Kod Do Radia M Seria Kalkulator i Generator Kodu RadiaFord M Seria Pre code składa się z sześciu cyfr (zignoruj i NIE WPISUJ pierwszej literki M). 6 /^([0-9]{6})$/
Ford Kod Do Radia V Seria Kalkulator i Generator Kodu RadiaFord V Seria Pre code składa się z sześciu cyfr (zignoruj i NIE WPISUJ pierwszej literki V). 6 /^([0-9]{6})$/
Ford TravelPilot EX, FX i NX Kod Do Radia Generator i KalkulatorFord TravelPilot EX, FX i NX Ostatnie 7 cyfr numeru seryjnego. 7 /^([0-9]{7})$/
Toyota ERC Kalkulator i Generator Kodu Do Odblokowania RadiaToyota ERC Kod ERC składa się z 16 cyfr i liter. 16 /^([A-Z0-9]{16})$/i
Jeep Cherokee Kod Do Odblokowania Radia Kalkulator i GeneratorJeep Cherokee Numer seryjny składa się z 14 znaków i cyfr (pomiń spacje). Upewnij się, że kod dostawcy (ang. supplier code) zaczyna się od cyfr 17719. 14 /^([A-Z0-9]{10}[0-9]{4})$/i
Chrysler Panasonic TM9 Kalkulator i Generator Kodu Do RadiaChrysler Panasonic TM9 Ostatnie 4 cyfry numeru seryjnego. Upewnij się, że numer seryjny rozpoczyna się od znaków TM9 np. T M9 XXX X X1234. 4 /^([0-9]{4})$/
Kod do radia Chrysler Dodge Ram Uconnect Harman Kardon VP2Chrysler Dodge Uconnect VP2 Ostatnie 4 znaki numeru seryjnego. Upewnij się, że numer seryjny rozpoczyna się od znaków TVPQN i to radio model VP2. 4 /^([A-Z0-9]{4})$/
Fiat Stilo i Bravo Kod Do Radia Visteon Kalkulator i GeneratorFiat Stilo i Bravo (Visteon) Pre code składa się z sześciu cyfr (zignoruj i NIE WPISUJ pierwszej literki M). 6 /^([A-Z0-9]{6})$/i
Fiat DAIICHI Kod Do Radia MOPAR Kalkulator i GeneratorFiat DAIICHI MOPAR Ostatnie 4 cyfry numeru seryjnego (zignoruj i NIE WPISUJ pierwszej literki). 4 /^([0-9]{4})$/i
Continental Fiat 250 i 500 VP1/VP2 Kod Do Radia Kalkulator i GeneratorFiat 250 i 500 VP1/VP2 Kod zaczyna się od znaków A2C i 16 cyfr. Wpisz jedynie ostatnie 4 cyfry numeru seryjnego. 4 /^([0-9]{4})$/i
Nissan Kalkulator Kodu PIN z Numeru SchowkaNissan PIN Immobilizera Kod schowka składa się z 12 cyfr i liter. 12 /^([A-Z0-9]{12})$/i
Eclipse ESN Kalkulator Kodu OdblokowującegoEclipse ESN Kod ESN składa się z 6 cyfr i liter. 6 /^([A-Z0-9]{6})$/i
Jaguar Alpine Kalkulator Kodu Odblokowującego Radio SamochodoweJaguar Alpine Ostatnie 5 cyfr numeru seryjnego. 5 /^([0-9]{5})$/

Przykłady użycia

Generowanie kodu radiowego

W tym przykładzie zaprezentowane jest generowanie kodu dla wybranego modelu radiowego. Cała walidacja parametrów wejściowych odbywa się po stronie serwera i jeśli numer seryjny radia będzie posiadał nieprawidłową długość lub wzorzec - usługa zwróci błąd.

<?php declare(strict_types=1);

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * type of car radio.
 *
 * Wersja      : v1.1.5
 * PHP          : >= 8
 * Zależności  : cURL
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use PELock\RadioCodeCalculator\RadioCodeCalculator;
use PELock\RadioCodeCalculator\RadioErrors;
use PELock\RadioCodeCalculator\RadioModels;

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
$myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// wygeneruj kod radia (przez Web API)
//
list($error, $result) = $myRadioCodeCalculator->calc(RadioModels::get(RadioModels::FORD_M_SERIES), "123456");

switch($error)
{
        case RadioErrors::SUCCESS: echo "Radio code is " . $result["code"]; break;
        case RadioErrors::INVALID_RADIO_MODEL: echo "Nieprawidłowy model radia (nieobsługiwany)"; break;
        case RadioErrors::INVALID_SERIAL_LENGTH: echo "Nieprawidłowa długość numeru seryjnego (oczekiwano " . $result["serialMaxLen"] . " znaków)"; break;
        case RadioErrors::INVALID_SERIAL_PATTERN: echo "Nieprawidłowy wzorzec numeru seryjnego (oczekiwano " . $result["serialRegexPattern"]["php"] . ")"; break;
        case RadioErrors::INVALID_SERIAL_NOT_SUPPORTED: echo "Ten numer seryjny nie jest obsługiwany"; break;
        case RadioErrors::INVALID_EXTRA_LENGTH: echo "Nieprawidłowa długość danych dodatkowych (oczekiwano " . $result["extraMaxLen"] . " znaków)"; break;
        case RadioErrors::INVALID_EXTRA_PATTERN: echo "Nieprawidłowy wzorzec danych dodatkowych (oczekiwano " . $result["extraRegexPattern"]["php"] . ""; break;
        case RadioErrors::INVALID_INPUT: echo "Nieprawidłowe dane wejściowe"; break;
        case RadioErrors::INVALID_COMMAND: echo "Nieprawidłowe polecenie wysłane do interfejsu Web API"; break;
        case RadioErrors::INVALID_LICENSE: echo "Nieprawidłowy klucz licencji!"; break;
        default: echo "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {error})."; break;
}
#!/usr/bin/env python

###############################################################################
#
# Radio Code Calculator API — przykład użycia interfejsu Web API
#
# W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
# type of car radio.
#
# Wersja        : v1.1.0
# Język       : Python
# Autor         : Bartosz Wójcik
# Project        : https://www.pelock.com/products/radio-code-calculator
# Homepage       : https://www.pelock.com
#
###############################################################################

#
# dołącz moduł Radio Code Calculator API
#
from radio_code_calculator import *

#
# utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
#
myRadioCodeCalculator = RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD")

#
# wygeneruj kod radia (przez Web API)
#
error, result = myRadioCodeCalculator.calc(RadioModels.FORD_M_SERIES, "123456")

if error == RadioErrors.SUCCESS:
    print(f'Radio code is {result["code"]}')
elif error == RadioErrors.INVALID_RADIO_MODEL:
    print("Nieprawidłowy model radia (nieobsługiwany)")
elif error == RadioErrors.INVALID_SERIAL_LENGTH:
    print(f'Nieprawidłowa długość numeru seryjnego (oczekiwano {result["serialMaxLen"]} znaków)')
elif error == RadioErrors.INVALID_SERIAL_PATTERN:
    print(f'Nieprawidłowy wzorzec numeru seryjnego (oczekiwano {result["serialRegexPattern"]["python"]})')
elif error == RadioErrors.INVALID_SERIAL_NOT_SUPPORTED:
    print("Ten numer seryjny nie jest obsługiwany")
elif error == RadioErrors.INVALID_EXTRA_LENGTH:
    print(f'Nieprawidłowa długość danych dodatkowych (oczekiwano {result["extraMaxLen"]} znaków)')
elif error == RadioErrors.INVALID_EXTRA_PATTERN:
    print(f'Nieprawidłowy wzorzec danych dodatkowych (oczekiwano {result["extraRegexPattern"]["python"]})')
elif error == RadioErrors.INVALID_INPUT:
    print("Nieprawidłowe dane wejściowe")
elif error == RadioErrors.INVALID_COMMAND:
    print("Nieprawidłowe polecenie wysłane do interfejsu Web API")
elif error == RadioErrors.INVALID_LICENSE:
    print("Nieprawidłowy klucz licencji")
elif error == RadioErrors.ERROR_CONNECTION:
    print("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.")
else:
    print(f'Nieznany błąd {error}')
"use strict";

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * type of car radio.
 *
 * Wersja      : v1.1.5
 * JS           : ES6
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
import { RadioCodeCalculator, RadioErrors, RadioModel, RadioModels } from "radio-code-calculator";

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
let myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// wygeneruj kod radia (przez Web API)
//
myRadioCodeCalculator.calc(RadioModels.FORD_M_SERIES, "123456").then((result) => {

    console.log("Radio code is " + result["code"]);

}).catch((error) => {

    switch(error["error"])
    {
    case RadioErrors.INVALID_RADIO_MODEL: console.log("Nieprawidłowy model radia (nieobsługiwany)"); break;
    case RadioErrors.INVALID_SERIAL_LENGTH: console.log("Nieprawidłowa długość numeru seryjnego (oczekiwano " + result["serialMaxLen"] + " znaków)"); break;
    case RadioErrors.INVALID_SERIAL_PATTERN: console.log("Nieprawidłowy wzorzec numeru seryjnego (oczekiwano " + result["serialRegexPattern"]["php"] + ")"); break;
    case RadioErrors.INVALID_SERIAL_NOT_SUPPORTED: console.log("Ten numer seryjny nie jest obsługiwany"); break;
    case RadioErrors.INVALID_EXTRA_LENGTH: console.log("Nieprawidłowa długość danych dodatkowych (oczekiwano " + result["extraMaxLen"] + " znaków)"); break;
    case RadioErrors.INVALID_EXTRA_PATTERN: console.log("Nieprawidłowy wzorzec danych dodatkowych (oczekiwano " + result["extraRegexPattern"]["php"] + ""); break;
    case RadioErrors.INVALID_INPUT: console.log("Nieprawidłowe dane wejściowe"); break;
    case RadioErrors.INVALID_COMMAND: console.log("Nieprawidłowe polecenie wysłane do interfejsu Web API"); break;
    case RadioErrors.INVALID_LICENSE: console.log("Nieprawidłowy klucz licencji!"); break;
    default: console.log(`Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu ${error}).`); break;
    }
});
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * type of car radio.
 *
 * Wersja      : v1.0.0
 * Rust         : 2021
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2026 PELock LLC
 * @license Apache-2.0
 *
 *****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use radio_code_calculator::{RadioCodeCalculator, RadioCodeCalculatorError, RadioErrors, RadioModels};

#[tokio::main]
async fn main() {
    //
    // utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
    //
    let my_radio_code_calculator =
        RadioCodeCalculator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // wygeneruj kod radia (przez Web API)
    //
    match my_radio_code_calculator
        .calc(&*RadioModels::FORD_M_SERIES, "123456", "")
        .await
    {
        Ok(result) => {
            println!("Radio code is {}", result["code"]);
        }
        Err(e) => match e {
            RadioCodeCalculatorError::ApiError(ref v) => match v["error"].as_i64().unwrap_or(-1) as i32 {
                RadioErrors::INVALID_RADIO_MODEL => {
                    println!("Nieprawidłowy model radia (nieobsługiwany)");
                },
                RadioErrors::INVALID_SERIAL_LENGTH => println!(
                    "Nieprawidłowa długość numeru seryjnego (oczekiwano {} znaków)",
                    v["serialMaxLen"]
                ),
                RadioErrors::INVALID_SERIAL_PATTERN => println!(
                    "Nieprawidłowy wzorzec numeru seryjnego (oczekiwano {})",
                    v["serialRegexPattern"]["php"]
                ),
                RadioErrors::INVALID_SERIAL_NOT_SUPPORTED => {
                    println!("Ten numer seryjny nie jest obsługiwany");
                },
                RadioErrors::INVALID_EXTRA_LENGTH => println!(
                    "Nieprawidłowa długość danych dodatkowych (oczekiwano {} znaków)",
                    v["extraMaxLen"]
                ),
                RadioErrors::INVALID_EXTRA_PATTERN => println!(
                    "Nieprawidłowy wzorzec danych dodatkowych (oczekiwano {}",
                    v["extraRegexPattern"]["php"]
                ),
                RadioErrors::INVALID_INPUT => println!("Nieprawidłowe dane wejściowe"),
                RadioErrors::INVALID_COMMAND => {
                    println!("Nieprawidłowe polecenie wysłane do interfejsu Web API");
                },
                RadioErrors::INVALID_LICENSE => println!("Nieprawidłowy klucz licencji!"),
                _ => println!("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {v:?})."),
            },
            RadioCodeCalculatorError::InvalidLicense => println!("Nieprawidłowy klucz licencji!"),
            RadioCodeCalculatorError::Transport(msg) => {
                println!("Błąd połączenia: {msg}");
            }
        },
    }
}
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * type of car radio.
 *
 * Wersja      : v.1.0.0
 * Język     : C#
 * Zależności  : RadioCodeCalculator (NuGet / project reference)
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;

var myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

try
{
    var result = await myRadioCodeCalculator.CalcAsync(RadioModels.FordMSeries, "123456");
    Console.WriteLine("Radio code is " + result["code"]?.ToString());
}
catch (RadioApiException ex)
{
    switch (ex.ErrorCode)
    {
        case RadioErrors.InvalidRadioModel:
            Console.WriteLine("Nieprawidłowy model radia (nieobsługiwany)");
            break;
        case RadioErrors.InvalidSerialLength:
            Console.WriteLine("Nieprawidłowa długość numeru seryjnego (oczekiwano " + ex.Response["serialMaxLen"] + " znaków)");
            break;
        case RadioErrors.InvalidSerialPattern:
            Console.WriteLine("Nieprawidłowy wzorzec numeru seryjnego (oczekiwano " +
                              ex.Response["serialRegexPattern"]?["php"] + ")");
            break;
        case RadioErrors.InvalidSerialNotSupported:
            Console.WriteLine("Ten numer seryjny nie jest obsługiwany");
            break;
        case RadioErrors.InvalidExtraLength:
            Console.WriteLine("Nieprawidłowa długość danych dodatkowych (oczekiwano " + ex.Response["extraMaxLen"] + " znaków)");
            break;
        case RadioErrors.InvalidExtraPattern:
            Console.WriteLine("Nieprawidłowy wzorzec danych dodatkowych (oczekiwano " +
                              ex.Response["extraRegexPattern"]?["php"] + ")");
            break;
        case RadioErrors.InvalidInput:
            Console.WriteLine("Nieprawidłowe dane wejściowe");
            break;
        case RadioErrors.InvalidCommand:
            Console.WriteLine("Nieprawidłowe polecenie wysłane do interfejsu Web API");
            break;
        case RadioErrors.InvalidLicense:
            Console.WriteLine("Nieprawidłowy klucz licencji!");
            break;
        default:
            Console.WriteLine($"Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {ex.ErrorCode}).");
            break;
    }
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia.
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * type of car radio.
 *
 * Wersja      : v1.1.6
 * Język     : Go
 * Autor       : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	radiocodecalculator "github.com/PELock/Radio-Code-Calculator-Go"
)

func main() {
	client := radiocodecalculator.New("ABCD-ABCD-ABCD-ABCD")
	errCode, result, err := client.Calc(context.Background(), radiocodecalculator.FordMSeries, "123456", "")
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	switch errCode {
	case radiocodecalculator.ErrorSuccess:
		fmt.Println("Radio code is", result["code"])
	case radiocodecalculator.ErrorInvalidRadioModel:
		fmt.Println("Nieprawidłowy model radia (nieobsługiwany)")
	case radiocodecalculator.ErrorInvalidSerialLength:
		fmt.Println("Nieprawidłowa długość numeru seryjnego")
	case radiocodecalculator.ErrorInvalidSerialPattern:
		fmt.Println("Nieprawidłowy wzorzec numeru seryjnego")
	case radiocodecalculator.ErrorInvalidLicense:
		fmt.Println("Nieprawidłowy klucz licencji!")
	default:
		fmt.Printf("Podczas komunikacji z usługą wydarzyło się coś nieoczekiwanego (kod błędu %d).\n", errCode)
	}
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * type of car radio.
 *
 * Wersja        : v1.1.6
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.pelock.radiocode.RadioApiResult;
import com.pelock.radiocode.RadioCodeCalculator;
import com.pelock.radiocode.RadioErrors;
import com.pelock.radiocode.RadioModels;

public class RadioCodeCalculatorSimple {

  public static void main(String[] args) throws Exception {
    RadioCodeCalculator client = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");
    RadioApiResult result = client.calc(RadioModels.FORD_M_SERIES, "123456");

    switch (result.getError()) {
      case RadioErrors.SUCCESS:
        System.out.println("Radio code is " + result.getCode());
        break;
      case RadioErrors.INVALID_RADIO_MODEL:
        System.out.println("Nieprawidłowy model radia (nieobsługiwany)");
        break;
      case RadioErrors.INVALID_SERIAL_LENGTH:
        System.out.println("Nieprawidłowa długość numeru seryjnego");
        break;
      case RadioErrors.INVALID_SERIAL_PATTERN:
        System.out.println("Nieprawidłowy wzorzec numeru seryjnego");
        break;
      case RadioErrors.INVALID_LICENSE:
        System.out.println("Nieprawidłowy klucz licencji!");
        break;
      default:
        System.out.println("Podczas komunikacji z usługą wydarzyło się coś nieoczekiwanego (kod błędu " + result.getError() + ").");
        break;
    }
  }
}
################################################################################
#
# Radio Code Calculator — przykład użycia interfejsu Web API.
#
# Wygeneruj kod dla konkretnego modelu radia.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module RadioCodeCalculator

$myRadioCodeCalculator = New-RadioCodeCalculator -ApiKey 'ABCD-ABCD-ABCD-ABCD'
$apiError, $result = $myRadioCodeCalculator.Calc([RadioModels]::Get([RadioModels]::FORD_M_SERIES), '123456')

switch ($apiError) {
    ([RadioErrors]::SUCCESS) { Write-Host ("Radio code is {0}" -f $result.code) }
    ([RadioErrors]::INVALID_RADIO_MODEL) { Write-Host 'Nieprawidłowy model radia (nieobsługiwany)' }
    ([RadioErrors]::INVALID_SERIAL_LENGTH) { Write-Host ("Nieprawidłowa długość numeru seryjnego (oczekiwano {0} znaków)" -f $result.serialMaxLen) }
    ([RadioErrors]::INVALID_SERIAL_PATTERN) { Write-Host 'Nieprawidłowy wzorzec numeru seryjnego' }
    ([RadioErrors]::INVALID_SERIAL_NOT_SUPPORTED) { Write-Host 'Ten numer seryjny nie jest obsługiwany' }
    ([RadioErrors]::INVALID_EXTRA_LENGTH) { Write-Host ("Nieprawidłowa długość danych dodatkowych (oczekiwano {0} znaków)" -f $result.extraMaxLen) }
    ([RadioErrors]::INVALID_EXTRA_PATTERN) { Write-Host 'Nieprawidłowy wzorzec danych dodatkowych' }
    ([RadioErrors]::INVALID_INPUT) { Write-Host 'Nieprawidłowe dane wejściowe' }
    ([RadioErrors]::INVALID_COMMAND) { Write-Host 'Nieprawidłowe polecenie wysłane do interfejsu Web API' }
    ([RadioErrors]::INVALID_LICENSE) { Write-Host 'Nieprawidłowy klucz licencji!' }
    default { Write-Host ("Podczas komunikacji z usługą wydarzyło się coś nieoczekiwanego (kod błędu {0})." -f $apiError) }
}
# frozen_string_literal: true

###############################################################################
#
# Radio Code Calculator — generowanie kodu
#
# Wersja        : v1.1.6
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "radio-code-calculator"

client = RadioCodeCalculator.new("ABCD-ABCD-ABCD-ABCD")
error, result = client.calc(RadioModels.get(RadioModels::FORD_M_SERIES), "123456")

case error
when RadioErrors::SUCCESS
  puts "Radio code is #{result["code"]}"
when RadioErrors::INVALID_RADIO_MODEL
  puts "Nieprawidłowy model radia (nieobsługiwany)"
when RadioErrors::INVALID_SERIAL_LENGTH
  puts "Nieprawidłowa długość numeru seryjnego"
when RadioErrors::INVALID_SERIAL_PATTERN
  puts "Nieprawidłowy wzorzec numeru seryjnego"
when RadioErrors::INVALID_LICENSE
  puts "Nieprawidłowy klucz licencji!"
else
  puts "Podczas komunikacji z usługą wydarzyło się coś nieoczekiwanego (kod błędu #{error})."
end
#!/usr/bin/env bash

###############################################################################
#
# Radio Code Calculator — przykład użycia interfejsu REST.
#
# W tym przykładzie wygenerujemy kod dla radia Ford serii M.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# oblicz kod radia
#
# Treść JSON:
#
# error  - kod błędu (0 = sukces)
# code   - obliczony kod radia

curl -sS \
  -H "Authorization: Bearer ${API_KEY}" \
  -d "radio_model=ford-m-series" \
  -d "serial=123456" \
  "https://www.pelock.com/api/radio-code-calculator/v1/codes"

Generowanie kodu radiowego z dodatkową walidacją w trybie offline

Kody radiowe generowane są na podstawie wejściowych parametrów takich jak m.in. numer seryjny radia.

Numery seryjne radia różnią się dla różnych raddioodtwarzaczy, mają różną długość i różny wzór, jedne mogą się składać z samych cyfr np. 1234, a inne z cyfr i liter np. AB1234XYZ.

Walidacja tych danych odbywa się po stronie serwera. Jednak dla usprawnienia działania, możemy wykorzystać informacje o dostępnych limitach i wzorcach poszczególnych numerów seryjnych, aby np. ustawić te ograniczenia w kontrolkach we własnych aplikacjach bez zbędnego wywoływania zapytań do interfejsu Web API.

<?php declare(strict_types=1);

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * typu radia samochodowego. Ten przykład pokazuje rozszerzoną walidację offline
 * validation.
 *
 * Wersja      : v1.1.5
 * PHP          : >= 8
 * Zależności  : cURL
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use PELock\RadioCodeCalculator\RadioCodeCalculator;
use PELock\RadioCodeCalculator\RadioErrors;
use PELock\RadioCodeCalculator\RadioModel;
use PELock\RadioCodeCalculator\RadioModels;

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
$myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// wygeneruj pojedynczy kod odblokowania radia
//
$serial = "123456";
$extra = "";

//
// wybierz model radia
//
$radioModel = RadioModels::get(RadioModels::FORD_M_SERIES);

//
// wyświetl informacje o modelu radia; możesz nimi ograniczyć kontrolki, np.
//
// textFieldRadioSerial.maxLength = radioModel->serial_max_len
// textFieldRadioSerial.regEx = radioModel->serial_regex_pattern()
//
// (jeśli kontrolki na to pozwalają)
//
echo "Model radia $radioModel->name oczekuje numeru seryjnego o długości $radioModel->serial_max_len i wzorcu {$radioModel->serial_regex_pattern()}<br>";

// dodatkowe informacje
if ($radioModel->extra_max_len > 0)
{
        echo "Dodatkowo wymagane jest pole dodatkowe o długości $radioModel->extra_max_len i wzorcu {$radioModel->extra_regex_pattern()}<br>";
}

//
// sprawdź numer seryjny (offline) przed wysłaniem zapytania Web API
//
$error = $radioModel->validate($serial, $extra);

if ($error !== RadioErrors::SUCCESS)
{
    if ($error === RadioErrors::INVALID_SERIAL_LENGTH)
        echo "Nieprawidłowa długość numeru seryjnego (oczekiwano $radioModel->serial_max_len znaków<br>";
    else if ($error == RadioErrors::INVALID_SERIAL_PATTERN)
        echo "Nieprawidłowy wzorzec numeru seryjnego (oczekiwano $radioModel->serial_regex_pattern())<br>";
    else if ($error == RadioErrors::INVALID_SERIAL_NOT_SUPPORTED)
        echo "Ten numer seryjny nie jest obsługiwany";
    else if ($error == RadioErrors::INVALID_EXTRA_LENGTH)
        echo "Nieprawidłowa długość danych dodatkowych (oczekiwano $radioModel->extra_max_len znaków)<br>";
    else if ($error == RadioErrors::INVALID_EXTRA_PATTERN)
        echo "Nieprawidłowy wzorzec danych dodatkowych (oczekiwano $radioModel->extra_regex_pattern())<br>";

    exit(1);
}

//
// wygeneruj kod radia (przez Web API)
//
list($error, $result) = $myRadioCodeCalculator->calc($radioModel, $serial);

switch($error)
{
        case RadioErrors::SUCCESS: echo "Radio code is " . $result["code"]; break;
        case RadioErrors::INVALID_RADIO_MODEL: echo "Nieprawidłowy model radia (nieobsługiwany)"; break;
        case RadioErrors::INVALID_SERIAL_LENGTH: echo "Nieprawidłowa długość numeru seryjnego (oczekiwano " . $result["serialMaxLen"] . " znaków)"; break;
        case RadioErrors::INVALID_SERIAL_PATTERN: echo "Nieprawidłowy wzorzec numeru seryjnego (oczekiwano " . $result["serialRegexPattern"]["php"] . ")"; break;
        case RadioErrors::INVALID_SERIAL_NOT_SUPPORTED: echo "Ten numer seryjny nie jest obsługiwany"; break;
        case RadioErrors::INVALID_EXTRA_LENGTH: echo "Nieprawidłowa długość danych dodatkowych (oczekiwano " . $result["extraMaxLen"] . " znaków)"; break;
        case RadioErrors::INVALID_EXTRA_PATTERN: echo "Nieprawidłowy wzorzec danych dodatkowych (oczekiwano " . $result["extraRegexPattern"]["php"] . ""; break;
        case RadioErrors::INVALID_INPUT: echo "Nieprawidłowe dane wejściowe"; break;
        case RadioErrors::INVALID_COMMAND: echo "Nieprawidłowe polecenie wysłane do interfejsu Web API"; break;
        case RadioErrors::INVALID_LICENSE: echo "Nieprawidłowy klucz licencji!"; break;
        default: echo "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {error})."; break;
}
#!/usr/bin/env python

###############################################################################
#
# Radio Code Calculator API — przykład użycia interfejsu Web API
#
# W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
# typu radia samochodowego. Ten przykład pokazuje rozszerzoną walidację offline
# validation.
#
# Wersja        : v1.1.0
# Język       : Python
# Autor         : Bartosz Wójcik
# Project        : https://www.pelock.com/products/radio-code-calculator
# Homepage       : https://www.pelock.com
#
###############################################################################

#
# dołącz moduł Radio Code Calculator API
#
from radio_code_calculator import *

#
# utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
#
myRadioCodeCalculator = RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD")

#
# wygeneruj pojedynczy kod odblokowania radia
#
serial: str = "123456"
extra: str = ""

#
# wybierz model radia
#
radioModel: RadioModel = RadioModels.FORD_M_SERIES

#
# wyświetl informacje o modelu radia; możesz nimi ograniczyć kontrolki, np.
#
# textFieldRadioSerial.maxLength = radioModel.serial_max_len
# textFieldRadioSerial.regEx = radioModel.serial_regex_pattern
#
# (jeśli kontrolki na to pozwalają)
#
print(f'Model radia {radioModel.name} oczekuje numeru seryjnego o długości {radioModel.serial_max_len}'
      f' i wzorcu {radioModel.serial_regex_pattern}')

# dodatkowe informacje
if radioModel.extra_max_len > 0:
    print(f'Dodatkowo wymagane jest pole dodatkowe o długości {radioModel.extra_max_len}'
          f' i wzorcu {radioModel.extra_regex_pattern}')

#
# sprawdź numer seryjny (offline) przed wysłaniem zapytania Web API
#
error = radioModel.validate(serial, extra)

if error != RadioErrors.SUCCESS:

    if error == RadioErrors.INVALID_SERIAL_LENGTH:
        print(f'Nieprawidłowa długość numeru seryjnego (oczekiwano {radioModel.serial_max_len} znaków)')
    elif error == RadioErrors.INVALID_SERIAL_PATTERN:
        print(f'Nieprawidłowy wzorzec numeru seryjnego (oczekiwano {radioModel.serial_regex_pattern})')
    elif error == RadioErrors.INVALID_SERIAL_NOT_SUPPORTED:
        print("Ten numer seryjny nie jest obsługiwany")
    elif error == RadioErrors.INVALID_EXTRA_LENGTH:
        print(f'Nieprawidłowa długość danych dodatkowych (oczekiwano {radioModel.extra_max_len} znaków)')
    elif error == RadioErrors.INVALID_EXTRA_PATTERN:
        print(f'Nieprawidłowy wzorzec danych dodatkowych (oczekiwano {radioModel.extra_regex_pattern})')
    exit(1)

#
# wygeneruj kod radia (przez Web API)
#
error, result = myRadioCodeCalculator.calc(radioModel, "123456")

if error == RadioErrors.SUCCESS:
    print(f'Radio code is {result["code"]}')
elif error == RadioErrors.INVALID_RADIO_MODEL:
    print("Nieprawidłowy model radia (nieobsługiwany)")
elif error == RadioErrors.INVALID_SERIAL_LENGTH:
    print(f'Nieprawidłowa długość numeru seryjnego (oczekiwano {result["serialMaxLen"]} znaków)')
elif error == RadioErrors.INVALID_SERIAL_PATTERN:
    print(f'Nieprawidłowy wzorzec numeru seryjnego (oczekiwano {result["serialRegexPattern"]["python"]})')
elif error == RadioErrors.INVALID_SERIAL_NOT_SUPPORTED:
    print("Ten numer seryjny nie jest obsługiwany")
elif error == RadioErrors.INVALID_EXTRA_LENGTH:
    print(f'Nieprawidłowa długość danych dodatkowych (oczekiwano {result["extraMaxLen"]} znaków)')
elif error == RadioErrors.INVALID_EXTRA_PATTERN:
    print(f'Nieprawidłowy wzorzec danych dodatkowych (oczekiwano {result["extraRegexPattern"]["python"]})')
elif error == RadioErrors.INVALID_INPUT:
    print("Nieprawidłowe dane wejściowe")
elif error == RadioErrors.INVALID_COMMAND:
    print("Nieprawidłowe polecenie wysłane do interfejsu Web API")
elif error == RadioErrors.INVALID_LICENSE:
    print("Nieprawidłowy klucz licencji")
elif error == RadioErrors.ERROR_CONNECTION:
    print("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.")
else:
    print(f'Nieznany błąd {error}')
"use strict";

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * typu radia samochodowego. Ten przykład pokazuje rozszerzoną walidację offline
 * validation.
 *
 * Wersja      : v1.1.5
 * JS           : ES6
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
import { RadioCodeCalculator, RadioErrors, RadioModel, RadioModels } from "radio-code-calculator";

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
let myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// wygeneruj pojedynczy kod odblokowania radia
//
let serial = "123456";
let extra = "";

//
// wybierz model radia
//
let radioModel = RadioModels.FORD_M_SERIES;

//
// wyświetl informacje o modelu radia; możesz nimi ograniczyć kontrolki, np.
//
// textFieldRadioSerial.maxLength = radioModel.serial_max_len
// textFieldRadioSerial.regEx = radioModel.serial_regex_pattern()
//
// (jeśli kontrolki na to pozwalają)
//
console.log(`Model radia ${radioModel.name} oczekuje numeru seryjnego o długości ${radioModel.serial_max_len} i wzorcu ${radioModel.serial_regex_pattern()}<br>`);

// dodatkowe informacje
if (radioModel.extra_max_len > 0)
{
    console.log(`Dodatkowo wymagane jest pole dodatkowe o długości ${radioModel.extra_max_len} i wzorcu ${radioModel.extra_regex_pattern()}<br>`);
}

//
// sprawdź numer seryjny (offline) przed wysłaniem zapytania Web API
//
let error = radioModel.validate(serial, extra);

if (error !== RadioErrors.SUCCESS)
{
    if (error === RadioErrors.INVALID_SERIAL_LENGTH)
        console.log(`Nieprawidłowa długość numeru seryjnego (oczekiwano ${radioModel.serial_max_len} znaków<br>`);
    else if (error == RadioErrors.INVALID_SERIAL_PATTERN)
        console.log(`Nieprawidłowy wzorzec numeru seryjnego (oczekiwano ${radioModel.serial_regex_pattern()})<br>`);
    else if (error == RadioErrors.INVALID_SERIAL_NOT_SUPPORTED)
        console.log("Ten numer seryjny nie jest obsługiwany");
    else if (error == RadioErrors.INVALID_EXTRA_LENGTH)
        console.log(`Nieprawidłowa długość danych dodatkowych (oczekiwano ${radioModel.extra_max_len} znaków)<br>`);
    else if (error == RadioErrors.INVALID_EXTRA_PATTERN)
        console.log(`Nieprawidłowy wzorzec danych dodatkowych (oczekiwano ${radioModel.extra_regex_pattern()})<br>`);

    process.exit(1);
}

//
// wygeneruj kod radia (przez Web API)
//
myRadioCodeCalculator.calc(radioModel, serial).then((result) => {

    console.log("Radio code is " + result["code"]);

}).catch((error) => {

    switch(error["error"])
    {
    case RadioErrors.INVALID_RADIO_MODEL: console.log("Nieprawidłowy model radia (nieobsługiwany)"); break;
    case RadioErrors.INVALID_SERIAL_LENGTH: console.log("Nieprawidłowa długość numeru seryjnego (oczekiwano " + result["serialMaxLen"] + " znaków)"); break;
    case RadioErrors.INVALID_SERIAL_PATTERN: console.log("Nieprawidłowy wzorzec numeru seryjnego (oczekiwano " + result["serialRegexPattern"]["php"] + ")"); break;
    case RadioErrors.INVALID_SERIAL_NOT_SUPPORTED: console.log("Ten numer seryjny nie jest obsługiwany"); break;
    case RadioErrors.INVALID_EXTRA_LENGTH: console.log("Nieprawidłowa długość danych dodatkowych (oczekiwano " + result["extraMaxLen"] + " znaków)"); break;
    case RadioErrors.INVALID_EXTRA_PATTERN: console.log("Nieprawidłowy wzorzec danych dodatkowych (oczekiwano " + result["extraRegexPattern"]["php"] + ""); break;
    case RadioErrors.INVALID_INPUT: console.log("Nieprawidłowe dane wejściowe"); break;
    case RadioErrors.INVALID_COMMAND: console.log("Nieprawidłowe polecenie wysłane do interfejsu Web API"); break;
    case RadioErrors.INVALID_LICENSE: console.log("Nieprawidłowy klucz licencji!"); break;
    default: console.log(`Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu ${error}).`); break;
    }
});
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * typu radia samochodowego. Ten przykład pokazuje rozszerzoną walidację offline
 * validation.
 *
 * Wersja      : v1.0.0
 * Rust         : 2021
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2026 PELock LLC
 * @license Apache-2.0
 *
 *****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use radio_code_calculator::{RadioCodeCalculator, RadioCodeCalculatorError, RadioErrors, RadioModels};

#[tokio::main]
async fn main() {
    //
    // utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
    //
    let my_radio_code_calculator =
        RadioCodeCalculator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // wygeneruj pojedynczy kod odblokowania radia
    //
    let serial = "123456";
    let extra = "";

    //
    // wybierz model radia
    //
    let radio_model = &*RadioModels::FORD_M_SERIES;

    //
    // wyświetl informacje o modelu radia; możesz nimi ograniczyć kontrolki, np.
    //
    // textFieldRadioSerial.maxLength = radioModel.serial_max_len
    // textFieldRadioSerial.regEx = radioModel.serial_regex_pattern()
    //
    // (jeśli kontrolki na to pozwalają)
    //
    println!(
        "Model radia {} oczekuje numeru seryjnego o długości {} i wzorcu {}<br>",
        radio_model.name,
        radio_model.serial_max_len,
        radio_model.serial_regex_pattern()
    );

    // dodatkowe informacje
    if radio_model.extra_max_len > 0 {
        println!(
            "Dodatkowo wymagane jest pole dodatkowe o długości {} i wzorcu {:?}<br>",
            radio_model.extra_max_len,
            radio_model.extra_regex_pattern()
        );
    }

    //
    // sprawdź numer seryjny (offline) przed wysłaniem zapytania Web API
    //
    let error = radio_model.validate(serial, Some(extra));

    if error != RadioErrors::SUCCESS {
        if error == RadioErrors::INVALID_SERIAL_LENGTH {
            println!(
                "Nieprawidłowa długość numeru seryjnego (oczekiwano {} znaków<br>",
                radio_model.serial_max_len
            );
        } else if error == RadioErrors::INVALID_SERIAL_PATTERN {
            println!(
                "Nieprawidłowy wzorzec numeru seryjnego (oczekiwano {})<br>",
                radio_model.serial_regex_pattern()
            );
        } else if error == RadioErrors::INVALID_SERIAL_NOT_SUPPORTED {
            println!("Ten numer seryjny nie jest obsługiwany");
        } else if error == RadioErrors::INVALID_EXTRA_LENGTH {
            println!(
                "Nieprawidłowa długość danych dodatkowych (oczekiwano {} znaków)<br>",
                radio_model.extra_max_len
            );
        } else if error == RadioErrors::INVALID_EXTRA_PATTERN {
            println!(
                "Nieprawidłowy wzorzec danych dodatkowych (oczekiwano {:?})<br>",
                radio_model.extra_regex_pattern()
            );
        }
        std::process::exit(1);
    }

    //
    // wygeneruj kod radia (przez Web API)
    //
    match my_radio_code_calculator
        .calc(radio_model, serial, extra)
        .await
    {
        Ok(result) => println!("Radio code is {}", result["code"]),
        Err(e) => match e {
            RadioCodeCalculatorError::ApiError(ref v) => match v["error"].as_i64().unwrap_or(-1) as i32 {
                RadioErrors::INVALID_RADIO_MODEL => {
                    println!("Nieprawidłowy model radia (nieobsługiwany)");
                },
                RadioErrors::INVALID_SERIAL_LENGTH => println!(
                    "Nieprawidłowa długość numeru seryjnego (oczekiwano {} znaków)",
                    v["serialMaxLen"]
                ),
                RadioErrors::INVALID_SERIAL_PATTERN => println!(
                    "Nieprawidłowy wzorzec numeru seryjnego (oczekiwano {})",
                    v["serialRegexPattern"]["php"]
                ),
                RadioErrors::INVALID_SERIAL_NOT_SUPPORTED => {
                    println!("Ten numer seryjny nie jest obsługiwany");
                },
                RadioErrors::INVALID_EXTRA_LENGTH => println!(
                    "Nieprawidłowa długość danych dodatkowych (oczekiwano {} znaków)",
                    v["extraMaxLen"]
                ),
                RadioErrors::INVALID_EXTRA_PATTERN => println!(
                    "Nieprawidłowy wzorzec danych dodatkowych (oczekiwano {})",
                    v["extraRegexPattern"]["php"]
                ),
                RadioErrors::INVALID_INPUT => println!("Nieprawidłowe dane wejściowe"),
                RadioErrors::INVALID_COMMAND => {
                    println!("Nieprawidłowe polecenie wysłane do interfejsu Web API");
                },
                RadioErrors::INVALID_LICENSE => println!("Nieprawidłowy klucz licencji!"),
                _ => println!("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {v:?})."),
            },
            RadioCodeCalculatorError::InvalidLicense => println!("Nieprawidłowy klucz licencji!"),
            RadioCodeCalculatorError::Transport(msg) => println!("Błąd połączenia: {msg}"),
        },
    }
}
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak wygenerować kod dla konkretnego
 * typu radia samochodowego. Ten przykład pokazuje rozszerzoną walidację offline
 * validation.
 *
 * Wersja      : v.1.0.0
 * Język     : C#
 * Zależności  : RadioCodeCalculator (NuGet / project reference)
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;

var myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

var serial = "123456";
var extra = "";

var radioModel = RadioModels.FordMSeries;

Console.WriteLine(
    $"Model radia {radioModel.Name} oczekuje numeru seryjnego o długości {radioModel.SerialMaxLen} i wzorcu {radioModel.SerialRegexPattern()}<br>");

if (radioModel.ExtraMaxLen > 0)
{
    Console.WriteLine(
        $"Dodatkowo wymagane jest pole dodatkowe o długości {radioModel.ExtraMaxLen} i wzorcu {radioModel.ExtraRegexPattern()}<br>");
}

var error = radioModel.Validate(serial, extra);

if (error != RadioErrors.Success)
{
    if (error == RadioErrors.InvalidSerialLength)
        Console.WriteLine($"Nieprawidłowa długość numeru seryjnego (oczekiwano {radioModel.SerialMaxLen} znaków<br>");
    else if (error == RadioErrors.InvalidSerialPattern)
        Console.WriteLine(
            $"Nieprawidłowy wzorzec numeru seryjnego (oczekiwano {radioModel.SerialRegexPattern()})<br>");
    else if (error == RadioErrors.InvalidSerialNotSupported)
        Console.WriteLine("Ten numer seryjny nie jest obsługiwany");
    else if (error == RadioErrors.InvalidExtraLength)
        Console.WriteLine($"Nieprawidłowa długość danych dodatkowych (oczekiwano {radioModel.ExtraMaxLen} znaków)<br>");
    else if (error == RadioErrors.InvalidExtraPattern)
        Console.WriteLine(
            $"Nieprawidłowy wzorzec danych dodatkowych (oczekiwano {radioModel.ExtraRegexPattern()})<br>");

    Environment.Exit(1);
}

try
{
    var result = await myRadioCodeCalculator.CalcAsync(radioModel, serial);
    Console.WriteLine("Radio code is " + result["code"]?.ToString());
}
catch (RadioApiException ex)
{
    switch (ex.ErrorCode)
    {
        case RadioErrors.InvalidRadioModel:
            Console.WriteLine("Nieprawidłowy model radia (nieobsługiwany)");
            break;
        case RadioErrors.InvalidSerialLength:
            Console.WriteLine("Nieprawidłowa długość numeru seryjnego (oczekiwano " + ex.Response["serialMaxLen"] + " znaków)");
            break;
        case RadioErrors.InvalidSerialPattern:
            Console.WriteLine("Nieprawidłowy wzorzec numeru seryjnego (oczekiwano " +
                              ex.Response["serialRegexPattern"]?["php"] + ")");
            break;
        case RadioErrors.InvalidSerialNotSupported:
            Console.WriteLine("Ten numer seryjny nie jest obsługiwany");
            break;
        case RadioErrors.InvalidExtraLength:
            Console.WriteLine("Nieprawidłowa długość danych dodatkowych (oczekiwano " + ex.Response["extraMaxLen"] + " znaków)");
            break;
        case RadioErrors.InvalidExtraPattern:
            Console.WriteLine("Nieprawidłowy wzorzec danych dodatkowych (oczekiwano " +
                              ex.Response["extraRegexPattern"]?["php"] + ")");
            break;
        case RadioErrors.InvalidInput:
            Console.WriteLine("Nieprawidłowe dane wejściowe");
            break;
        case RadioErrors.InvalidCommand:
            Console.WriteLine("Nieprawidłowe polecenie wysłane do interfejsu Web API");
            break;
        case RadioErrors.InvalidLicense:
            Console.WriteLine("Nieprawidłowy klucz licencji!");
            break;
        default:
            Console.WriteLine($"Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {ex.ErrorCode}).");
            break;
    }
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia.
 *
 * Wygeneruj kod radia po offline'owej walidacji numeru seryjnego.
 *
 * Wersja      : v1.1.6
 * Język     : Go
 * Autor       : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	radiocodecalculator "github.com/PELock/Radio-Code-Calculator-Go"
)

func main() {
	client := radiocodecalculator.New("ABCD-ABCD-ABCD-ABCD")
	model := radiocodecalculator.FordMSeries
	serial := "123456"
	extra := ""

	fmt.Printf("Model radia %s oczekuje numeru seryjnego o długości %d i wzorcu %s\n",
		model.Name, model.SerialMaxLen, model.SerialRegexPattern())

	if apiError := model.Validate(serial, extra); apiError != radiocodecalculator.ErrorSuccess {
		switch apiError {
		case radiocodecalculator.ErrorInvalidSerialLength:
			fmt.Printf("Nieprawidłowa długość numeru seryjnego (oczekiwano %d znaków)\n", model.SerialMaxLen)
		case radiocodecalculator.ErrorInvalidSerialPattern:
			fmt.Printf("Nieprawidłowy wzorzec numeru seryjnego (oczekiwano %s)\n", model.SerialRegexPattern())
		default:
			fmt.Printf("Walidacja nie powiodła się (kod błędu %d)\n", apiError)
		}
		os.Exit(1)
	}

	errCode, result, err := client.Calc(context.Background(), model, serial, extra)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if errCode == radiocodecalculator.ErrorSuccess {
		fmt.Println("Radio code is", result["code"])
	} else {
		fmt.Printf("Błąd API %d\n", errCode)
	}
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * Wygeneruj kod radia po offline'owej walidacji numeru seryjnego.
 *
 * Wersja        : v1.1.6
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.pelock.radiocode.RadioApiResult;
import com.pelock.radiocode.RadioCodeCalculator;
import com.pelock.radiocode.RadioErrors;
import com.pelock.radiocode.RadioModel;
import com.pelock.radiocode.RadioModels;

public class RadioCodeCalculatorOfflineValidation {

  public static void main(String[] args) throws Exception {
    RadioCodeCalculator client = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");
    RadioModel radioModel = RadioModels.FORD_M_SERIES;
    String serial = "123456";

    System.out.println(
        "Model radia "
            + radioModel.name
            + " oczekuje numeru seryjnego o długości "
            + radioModel.serialMaxLen
            + " i wzorcu "
            + radioModel.serialRegexPattern()
            + "");

    int apiError = radioModel.validate(serial, "");
    if (apiError != RadioErrors.SUCCESS) {
      if (apiError == RadioErrors.INVALID_SERIAL_LENGTH) {
        System.out.println("Nieprawidłowa długość numeru seryjnego (oczekiwano " + radioModel.serialMaxLen + " znaków)");
      } else if (apiError == RadioErrors.INVALID_SERIAL_PATTERN) {
        System.out.println("Nieprawidłowy wzorzec numeru seryjnego (oczekiwano " + radioModel.serialRegexPattern() + ")");
      } else {
        System.out.println("Walidacja nie powiodła się (kod błędu " + apiError + ")");
      }
      return;
    }

    RadioApiResult result = client.calc(radioModel, serial);
    if (result.getError() == RadioErrors.SUCCESS) {
      System.out.println("Radio code is " + result.getCode());
    } else {
      System.out.println("Błąd API " + result.getError());
    }
  }
}
################################################################################
#
# Radio Code Calculator — przykład użycia interfejsu Web API.
#
# Walidacja numeru seryjnego offline przed wywołaniem Web API.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module RadioCodeCalculator

$myRadioCodeCalculator = New-RadioCodeCalculator -ApiKey 'ABCD-ABCD-ABCD-ABCD'
$serial = '123456'
$extra = ''
$radioModel = [RadioModels]::Get([RadioModels]::FORD_M_SERIES)

Write-Host ("Model radia {0} oczekuje numeru seryjnego o długości {1} i wzorcu {2}" -f $radioModel.name, $radioModel.serial_max_len, $radioModel.serial_regex_pattern())

$apiError = $radioModel.validate($serial, $extra)
if ($apiError -ne [RadioErrors]::SUCCESS) {
    switch ($apiError) {
        ([RadioErrors]::INVALID_SERIAL_LENGTH) { Write-Host ("Nieprawidłowa długość numeru seryjnego (oczekiwano {0} znaków)" -f $radioModel.serial_max_len) }
        ([RadioErrors]::INVALID_SERIAL_PATTERN) { Write-Host ("Nieprawidłowy wzorzec numeru seryjnego (oczekiwano {0})" -f $radioModel.serial_regex_pattern()) }
        ([RadioErrors]::INVALID_EXTRA_LENGTH) { Write-Host ("Nieprawidłowa długość danych dodatkowych (oczekiwano {0} znaków)" -f $radioModel.extra_max_len) }
        ([RadioErrors]::INVALID_EXTRA_PATTERN) { Write-Host ("Nieprawidłowy wzorzec danych dodatkowych (oczekiwano {0})" -f $radioModel.extra_regex_pattern()) }
        default { Write-Host ("Walidacja nie powiodła się (kod błędu {0})" -f $apiError) }
    }
    exit 1
}

$apiError, $result = $myRadioCodeCalculator.Calc($radioModel, $serial)
if ($apiError -eq [RadioErrors]::SUCCESS) {
    Write-Host ("Radio code is {0}" -f $result.code)
}
else {
    Write-Host ("Błąd API {0}" -f $apiError)
}
# frozen_string_literal: true

###############################################################################
#
# Radio Code Calculator — walidacja offline
#
# Wersja        : v1.1.6
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "radio-code-calculator"

client = RadioCodeCalculator.new("ABCD-ABCD-ABCD-ABCD")
model = RadioModels.get(RadioModels::FORD_M_SERIES)
serial = "123456"

puts "Model radia #{model.name} oczekuje numeru seryjnego o długości #{model.serial_max_len} i wzorcu #{model.serial_regex_pattern}"

api_error = model.validate(serial)
unless api_error == RadioErrors::SUCCESS
  case api_error
  when RadioErrors::INVALID_SERIAL_LENGTH
    puts "Nieprawidłowa długość numeru seryjnego (oczekiwano #{model.serial_max_len} znaków)"
  when RadioErrors::INVALID_SERIAL_PATTERN
    puts "Nieprawidłowy wzorzec numeru seryjnego (oczekiwano #{model.serial_regex_pattern})"
  else
    puts "Walidacja nie powiodła się (kod błędu #{api_error})"
  end
  exit 1
end

error, result = client.calc(model, serial)
if error == RadioErrors::SUCCESS
  puts "Radio code is #{result["code"]}"
else
  puts "Błąd API #{error}"
end
#!/usr/bin/env bash

###############################################################################
#
# Radio Code Calculator — przykład użycia interfejsu REST.
#
# W tym przykładzie wygenerujemy kod po sprawdzeniach offline.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# sprawdzenia długości i regex w przykładzie są lokalne dla SDK.
# To nie jest wywołanie REST. Wywołanie sieciowe to to samo żądanie kodu.
#
# Treść JSON:
#
# error  - kod błędu (0 = sukces)
# code   - obliczony kod radia

curl -sS \
  -H "Authorization: Bearer ${API_KEY}" \
  -d "radio_model=ford-m-series" \
  -d "serial=123456" \
  "https://www.pelock.com/api/radio-code-calculator/v1/codes"

Pobieranie listy obsługiwanych kalkulatorów radiowych

Jeśli chciałbyś pobrać informację o wszystkich obsługiwanych modelach radioodtwarzaczy oraz ich parametrach takich jak długość numeru seryjnego i wzorzec - możesz to zrobić.

<?php declare(strict_types=1);

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pobierzemy listę wszystkich dostępnych kalkulatorów i ich
 * parametry takie jak nazwa, maksymalna długość numeru seryjnego radia i jego
 *.
 *
 * Wersja      : v1.1.5
 * PHP          : >= 8
 * Zależności  : cURL
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use PELock\RadioCodeCalculator\RadioCodeCalculator;
use PELock\RadioCodeCalculator\RadioErrors;

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
$myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// pobierz listę obsługiwanych kalkulatorów radiowych i ich parametrów (maks. długość, wzorzec regex)
//
list($error, $radio_models) = $myRadioCodeCalculator->list();

if ($error == RadioErrors::SUCCESS)
{
        echo "Supported radio models " . count($radio_models) . "<br>";

        foreach ($radio_models as $radio_model)
        {
                echo "Model radia name - $radio_model->name<br>";

                echo "Maks. długość numeru seryjnego radia - " . $radio_model->serial_max_len . "<br>";
                echo "Wzorzec regex numeru seryjnego radia - " . $radio_model->serial_regex_pattern() . "<br>";

                // is extra field specified?
                if ($radio_model->extra_max_len > 0)
                {
                        echo "Maks. długość danych dodatkowych radia - " . $radio_model->extra_max_len . "<br>";
                        echo "Wzorzec regex danych dodatkowych radia - " . $radio_model->extra_regex_pattern() . "<br>";
                        echo "<br>";
                }
        }
}
else if ($error == RadioErrors::INVALID_LICENSE)
        echo "Nieprawidłowy klucz licencji!";
else
        echo "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {error}).";
#!/usr/bin/env python

###############################################################################
#
# Radio Code Calculator API — przykład użycia interfejsu Web API
#
# W tym przykładzie pobierzemy listę wszystkich dostępnych kalkulatorów i ich
# parametry takie jak nazwa, maksymalna długość numeru seryjnego radia i jego
#.
#
# Wersja        : v1.1.0
# Język       : Python
# Autor         : Bartosz Wójcik
# Project        : https://www.pelock.com/products/radio-code-calculator
# Homepage       : https://www.pelock.com
#
###############################################################################

#
# dołącz moduł Radio Code Calculator API
#
from radio_code_calculator import *

#
# utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
#
myRadioCodeCalculator = RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD")

#
# pobierz listę obsługiwanych kalkulatorów radiowych i ich parametrów (maks. długość, wzorzec regex)
#
error, radio_models = myRadioCodeCalculator.list()

if error == RadioErrors.SUCCESS:

    print(f'Supported radio models {len(radio_models)}:\n')

    for radio_model in radio_models:

        print(f'Model radia name - {radio_model.name}')

        print(f'Maks. długość numeru seryjnego radia - {radio_model.serial_max_len}')
        print(f'Wzorzec regex numeru seryjnego radia - {radio_model.serial_regex_pattern}')

        # is extra field specified?
        if radio_model.extra_max_len > 0:
            print(f'Maks. długość danych dodatkowych radia - {radio_model.extra_max_len}')
            print(f'Wzorzec regex danych dodatkowych radia - {radio_model.extra_regex_pattern}')

        print()

elif error == RadioErrors.INVALID_LICENSE:
    print("Nieprawidłowy klucz licencji!")
else:
    print(f'Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {error}).')
"use strict";

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pobierzemy listę wszystkich dostępnych kalkulatorów i ich
 * parametry takie jak nazwa, maksymalna długość numeru seryjnego radia i jego
 *.
 *
 * Wersja      : v1.1.5
 * JS           : ES6
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
import { RadioCodeCalculator, RadioErrors, RadioModel, RadioModels } from "radio-code-calculator";

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
let myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// pobierz listę obsługiwanych kalkulatorów radiowych i ich parametrów (maks. długość, wzorzec regex)
//
myRadioCodeCalculator.list().then((result) => {

    let radio_models = result["radioModels"];

    console.log("Supported radio models " + radio_models.length + "<br>");

    radio_models.forEach(radio_model => {

        console.log("Model radia name - " + radio_model.name + "<br>");

        console.log("Maks. długość numeru seryjnego radia - " + radio_model.serial_max_len + "<br>");
        console.log("Wzorzec regex numeru seryjnego radia - " + radio_model.serial_regex_pattern() + "<br>");

        // is extra field specified?
        if (radio_model.extra_max_len > 0)
        {
            console.log("Maks. długość danych dodatkowych radia - " + radio_model.extra_max_len + "<br>");
            console.log("Wzorzec regex danych dodatkowych radia - " + radio_model.extra_regex_pattern() + "<br>");
            console.log("<br>");
        }

    });

}).catch((error) => {

    if (error["error"] == RadioErrors.INVALID_LICENSE)
        console.log("Nieprawidłowy klucz licencji!");
    else
        console.log(`Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu ${error}).`);
});
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pobierzemy listę wszystkich dostępnych kalkulatorów i ich
 * parametry takie jak nazwa, maksymalna długość numeru seryjnego radia i jego
 *.
 *
 * Wersja      : v1.0.0
 * Rust         : 2021
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2026 PELock LLC
 * @license Apache-2.0
 *
 *****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use radio_code_calculator::{RadioCodeCalculator, RadioCodeCalculatorError, RadioErrors};

#[tokio::main]
async fn main() {
    //
    // utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
    //
    let my_radio_code_calculator =
        RadioCodeCalculator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // pobierz listę obsługiwanych kalkulatorów radiowych i ich parametrów (maks. długość, wzorzec regex)
    //
    match my_radio_code_calculator.list().await {
        Ok(list) => {
            let radio_models = &list.radio_models;

            println!("Supported radio models {}<br>", radio_models.len());

            for radio_model in radio_models {
                println!("Model radia name - {}<br>", radio_model.name);

                println!(
                    "Maks. długość numeru seryjnego radia - {}<br>",
                    radio_model.serial_max_len
                );
                println!(
                    "Wzorzec regex numeru seryjnego radia - {}<br>",
                    radio_model.serial_regex_pattern()
                );

                // is extra field specified?
                if radio_model.extra_max_len > 0 {
                    println!(
                        "Maks. długość danych dodatkowych radia - {}<br>",
                        radio_model.extra_max_len
                    );
                    println!(
                        "Wzorzec regex danych dodatkowych radia - {:?}<br>",
                        radio_model.extra_regex_pattern()
                    );
                    println!("<br>");
                }
            }
        }
        Err(e) => match e {
            RadioCodeCalculatorError::ApiError(ref v) => {
                if v["error"].as_i64() == Some(RadioErrors::INVALID_LICENSE as i64) {
                    println!("Nieprawidłowy klucz licencji!");
                } else {
                    println!("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {v:?}).");
                }
            },
            RadioCodeCalculatorError::InvalidLicense => println!("Nieprawidłowy klucz licencji!"),
            RadioCodeCalculatorError::Transport(msg) => println!("Błąd połączenia: {msg}"),
        },
    }
}
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pobierzemy listę wszystkich dostępnych kalkulatorów i ich
 * parametry takie jak nazwa, maksymalna długość numeru seryjnego radia i jego
 *.
 *
 * Wersja      : v.1.0.0
 * Język     : C#
 * Zależności  : RadioCodeCalculator (NuGet / project reference)
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;

var myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

try
{
    var (radioModels, _) = await myRadioCodeCalculator.ListAsync();

    Console.WriteLine("Supported radio models " + radioModels.Count + "<br>");

    foreach (var radio_model in radioModels)
    {
        Console.WriteLine("Model radia name - " + radio_model.Name + "<br>");

        Console.WriteLine("Maks. długość numeru seryjnego radia - " + radio_model.SerialMaxLen + "<br>");
        Console.WriteLine("Wzorzec regex numeru seryjnego radia - " + radio_model.SerialRegexPattern() + "<br>");

        if (radio_model.ExtraMaxLen > 0)
        {
            Console.WriteLine("Maks. długość danych dodatkowych radia - " + radio_model.ExtraMaxLen + "<br>");
            Console.WriteLine("Wzorzec regex danych dodatkowych radia - " + radio_model.ExtraRegexPattern() + "<br>");
            Console.WriteLine("<br>");
        }
    }
}
catch (RadioApiException ex)
{
    if (ex.ErrorCode == RadioErrors.InvalidLicense)
        Console.WriteLine("Nieprawidłowy klucz licencji!");
    else
        Console.WriteLine($"Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {ex.ErrorCode}).");
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia.
 *
 * Pobierz listę obsługiwanych kalkulatorów kodów radiowych.
 *
 * Wersja      : v1.1.6
 * Język     : Go
 * Autor       : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	radiocodecalculator "github.com/PELock/Radio-Code-Calculator-Go"
)

func main() {
	client := radiocodecalculator.New("ABCD-ABCD-ABCD-ABCD")
	errCode, models, err := client.List(context.Background())
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if errCode == radiocodecalculator.ErrorInvalidLicense {
		fmt.Println("Nieprawidłowy klucz licencji!")
		os.Exit(1)
	}
	if errCode != radiocodecalculator.ErrorSuccess {
		fmt.Printf("Podczas komunikacji z usługą wydarzyło się coś nieoczekiwanego (kod błędu %d).\n", errCode)
		os.Exit(1)
	}
	fmt.Printf("Supported radio models %d\n", len(models))
	for _, m := range models {
		fmt.Printf("Model radia name - %s\n", m.Name)
		fmt.Printf("Maks. długość numeru seryjnego radia - %d\n", m.SerialMaxLen)
		fmt.Printf("Wzorzec regex numeru seryjnego radia - %s\n", m.SerialRegexPattern())
		if m.ExtraMaxLen > 0 {
			fmt.Printf("Maks. długość danych dodatkowych radia - %d\n", m.ExtraMaxLen)
			fmt.Printf("Wzorzec regex danych dodatkowych radia - %s\n", m.ExtraRegexPattern())
		}
	}
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * Pobierz listę obsługiwanych kalkulatorów kodów radiowych.
 *
 * Wersja        : v1.1.6
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.pelock.radiocode.RadioApiResult;
import com.pelock.radiocode.RadioCodeCalculator;
import com.pelock.radiocode.RadioErrors;
import com.pelock.radiocode.RadioModel;

public class RadioCodeCalculatorList {

  public static void main(String[] args) throws Exception {
    RadioCodeCalculator client = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");
    RadioApiResult result = client.list();

    if (result.getError() == RadioErrors.INVALID_LICENSE) {
      System.out.println("Nieprawidłowy klucz licencji!");
      return;
    }
    if (result.getError() != RadioErrors.SUCCESS) {
      System.out.println("Podczas komunikacji z usługą wydarzyło się coś nieoczekiwanego (kod błędu " + result.getError() + ").");
      return;
    }

    System.out.println("Supported radio models " + result.getModels().size());
    for (RadioModel radioModel : result.getModels()) {
      System.out.println("Model radia name - " + radioModel.name);
      System.out.println("Maks. długość numeru seryjnego radia - " + radioModel.serialMaxLen);
      System.out.println("Wzorzec regex numeru seryjnego radia - " + radioModel.serialRegexPattern());
      if (radioModel.extraMaxLen > 0) {
        System.out.println("Maks. długość danych dodatkowych radia - " + radioModel.extraMaxLen);
        System.out.println("Wzorzec regex danych dodatkowych radia - " + radioModel.extraRegexPattern());
      }
    }
  }
}
################################################################################
#
# Radio Code Calculator — przykład użycia interfejsu Web API.
#
# List supported radio calculators.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module RadioCodeCalculator

$myRadioCodeCalculator = New-RadioCodeCalculator -ApiKey 'ABCD-ABCD-ABCD-ABCD'
$apiError, $radioModels = $myRadioCodeCalculator.List()

if ($apiError -eq [RadioErrors]::SUCCESS) {
    Write-Host ("Supported radio models {0}" -f $radioModels.Count)
    foreach ($radioModel in $radioModels) {
        Write-Host ("Model radia name - {0}" -f $radioModel.name)
        Write-Host ("Maks. długość numeru seryjnego radia - {0}" -f $radioModel.serial_max_len)
        Write-Host ("Wzorzec regex numeru seryjnego radia - {0}" -f $radioModel.serial_regex_pattern())
        if ($radioModel.extra_max_len -gt 0) {
            Write-Host ("Maks. długość danych dodatkowych radia - {0}" -f $radioModel.extra_max_len)
            Write-Host ("Wzorzec regex danych dodatkowych radia - {0}" -f $radioModel.extra_regex_pattern())
        }
    }
}
elseif ($apiError -eq [RadioErrors]::INVALID_LICENSE) {
    Write-Host 'Nieprawidłowy klucz licencji!'
}
else {
    Write-Host ("Podczas komunikacji z usługą wydarzyło się coś nieoczekiwanego (kod błędu {0})." -f $apiError)
}
# frozen_string_literal: true

###############################################################################
#
# Radio Code Calculator — lista modeli
#
# Wersja        : v1.1.6
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "radio-code-calculator"

error, models = RadioCodeCalculator.new("ABCD-ABCD-ABCD-ABCD").list
if error == RadioErrors::SUCCESS
  puts "Supported radio models #{models.length}"
  models.each do |m|
    puts "Model radia name - #{m.name}"
    puts "Maks. długość numeru seryjnego radia - #{m.serial_max_len}"
    puts "Wzorzec regex numeru seryjnego radia - #{m.serial_regex_pattern}"
    if m.extra_max_len.positive?
      puts "Maks. długość danych dodatkowych radia - #{m.extra_max_len}"
      puts "Wzorzec regex danych dodatkowych radia - #{m.extra_regex_pattern}"
    end
  end
elsif error == RadioErrors::INVALID_LICENSE
  warn "Nieprawidłowy klucz licencji!"
else
  warn "Podczas komunikacji z usługą wydarzyło się coś nieoczekiwanego (kod błędu #{error})."
end
#!/usr/bin/env bash

###############################################################################
#
# Radio Code Calculator — przykład użycia interfejsu REST.
#
# W tym przykładzie pobierzemy listę obsługiwanych kalkulatorów radiowych.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# list supported radio models
#
# Treść JSON:
#
# supportedRadioModels - nazwa modelu, limity numeru seryjnego i limity pól dodatkowych

curl -sS \
  -H "Authorization: Bearer ${API_KEY}" \
  "https://www.pelock.com/api/radio-code-calculator/v1/radios"

Pobieranie parametrów wybranego kalkulatora radiowego

Możliwe jest pobranie parametrów wybranego kalkulatora

<?php declare(strict_types=1);

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak pobrać informacje o
 * konkretnym kalkulatorze radiowym i jego parametrach (maks. długość i wzorzec regex).
 *
 * Wersja      : v1.1.5
 * PHP          : >= 8
 * Zależności  : cURL
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use PELock\RadioCodeCalculator\RadioCodeCalculator;
use PELock\RadioCodeCalculator\RadioErrors;

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
$myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// pobierz informacje o modelu radia
//
list($error, $radio_model) = $myRadioCodeCalculator->info("ford-m-series");

if ($error === RadioErrors::SUCCESS)
{
	echo "Model radia name - " . $radio_model->name . "<br>";

	echo "Maks. długość numeru seryjnego radia - " . $radio_model->serial_max_len . "<br>";
	echo "Wzorzec regex numeru seryjnego radia - " . $radio_model->serial_regex_pattern() . "<br>";

	// is extra field specified?
	if ($radio_model->extra_max_len > 0)
	{
		echo "Maks. długość danych dodatkowych radia - " . $radio_model->extra_max_len . "<br>";
		echo "Wzorzec regex danych dodatkowych radia - " . $radio_model->extra_regex_pattern() . "<br>";
		echo "<br>";
	}
}
elseif ($error == RadioErrors::INVALID_LICENSE)
    echo "Nieprawidłowy klucz licencji!";
else
    echo "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {error}).";
#!/usr/bin/env python

###############################################################################
#
# Radio Code Calculator API — przykład użycia interfejsu Web API
#
# W tym przykładzie pokażemy, jak pobrać informacje o
# konkretnym kalkulatorze radiowym i jego parametrach (maks. długość i wzorzec regex).
#
# Wersja        : v1.1.0
# Język       : Python
# Autor         : Bartosz Wójcik
# Project        : https://www.pelock.com/products/radio-code-calculator
# Homepage       : https://www.pelock.com
#
###############################################################################

#
# dołącz moduł Radio Code Calculator API
#
from radio_code_calculator import *

#
# utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
#
myRadioCodeCalculator = RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD")

#
# pobierz informacje o modelu radia
#
error, radioModel = myRadioCodeCalculator.info("ford-m-series")

if error == RadioErrors.SUCCESS:

    print(f'Model radia name - {radioModel.name}')

    print(f'Maks. długość numeru seryjnego radia - {radioModel.serial_max_len}')
    print(f'Wzorzec regex numeru seryjnego radia - {radioModel.serial_regex_pattern}')

    # is extra field specified?
    if radioModel.extra_max_len > 0:
        print(f'Maks. długość danych dodatkowych radia - {radioModel.extra_max_len}')
        print(f'Wzorzec regex danych dodatkowych radia - {radioModel.extra_regex_pattern}')

    print()

elif error == RadioErrors.INVALID_LICENSE:
    print("Nieprawidłowy klucz licencji!")
else:
    print(f'Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {error}).')
"use strict";

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak pobrać informacje o
 * konkretnym kalkulatorze radiowym i jego parametrach (maks. długość i wzorzec regex).
 *
 * Wersja      : v1.1.5
 * JS           : ES6
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
import { RadioCodeCalculator, RadioErrors, RadioModel, RadioModels } from "radio-code-calculator";

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
let myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// pobierz informacje o modelu radia
//
myRadioCodeCalculator.info("ford-m-series").then((result) => {

    let radio_model = result["radioModel"];

    console.log("Model radia name - " + radio_model.name + "<br>");

    console.log("Maks. długość numeru seryjnego radia - " + radio_model.serial_max_len + "<br>");
    console.log("Wzorzec regex numeru seryjnego radia - " + radio_model.serial_regex_pattern() + "<br>");

    // is extra field specified?
    if (radio_model.extra_max_len > 0)
    {
        console.log("Maks. długość danych dodatkowych radia - " + radio_model.extra_max_len + "<br>");
        console.log("Wzorzec regex danych dodatkowych radia - " + radio_model.extra_regex_pattern() + "<br>");
        console.log("<br>");
    }

}).catch((error) => {
    if (error.error == RadioErrors.INVALID_LICENSE)
        console.log("Nieprawidłowy klucz licencji!");
    else
        console.log(`Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu ${error["error"]}).`);
});
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak pobrać informacje o
 * konkretnym kalkulatorze radiowym i jego parametrach (maks. długość i wzorzec regex).
 *
 * Wersja      : v1.0.0
 * Rust         : 2021
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2026 PELock LLC
 * @license Apache-2.0
 *
 *****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use radio_code_calculator::{RadioCodeCalculator, RadioCodeCalculatorError, RadioErrors};

#[tokio::main]
async fn main() {
    //
    // utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
    //
    let my_radio_code_calculator =
        RadioCodeCalculator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // pobierz informacje o modelu radia
    //
    match my_radio_code_calculator.info("ford-m-series").await {
        Ok(info) => {
            let radio_model = &info.radio_model;

            println!("Model radia name - {}<br>", radio_model.name);

            println!(
                "Maks. długość numeru seryjnego radia - {}<br>",
                radio_model.serial_max_len
            );
            println!(
                "Wzorzec regex numeru seryjnego radia - {}<br>",
                radio_model.serial_regex_pattern()
            );

            // is extra field specified?
            if radio_model.extra_max_len > 0 {
                println!(
                    "Maks. długość danych dodatkowych radia - {}<br>",
                    radio_model.extra_max_len
                );
                println!(
                    "Wzorzec regex danych dodatkowych radia - {:?}<br>",
                    radio_model.extra_regex_pattern()
                );
                println!("<br>");
            }
        }
        Err(e) => match e {
            RadioCodeCalculatorError::ApiError(v) => {
                if v["error"].as_i64() == Some(RadioErrors::INVALID_LICENSE as i64) {
                    println!("Nieprawidłowy klucz licencji!");
                } else {
                    println!(
                        "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {:?}).",
                        v["error"]
                    );
                }
            },
            RadioCodeCalculatorError::InvalidLicense => println!("Nieprawidłowy klucz licencji!"),
            RadioCodeCalculatorError::Transport(msg) => println!("Błąd połączenia: {msg}"),
        },
    }
}
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie pokażemy, jak pobrać informacje o
 * konkretnym kalkulatorze radiowym i jego parametrach (maks. długość i wzorzec regex).
 *
 * Wersja      : v.1.0.0
 * Język     : C#
 * Zależności  : RadioCodeCalculator (NuGet / project reference)
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;

var myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

try
{
    var (radio_model, _) = await myRadioCodeCalculator.InfoAsync("ford-m-series");

    Console.WriteLine("Model radia name - " + radio_model.Name + "<br>");

    Console.WriteLine("Maks. długość numeru seryjnego radia - " + radio_model.SerialMaxLen + "<br>");
    Console.WriteLine("Wzorzec regex numeru seryjnego radia - " + radio_model.SerialRegexPattern() + "<br>");

    if (radio_model.ExtraMaxLen > 0)
    {
        Console.WriteLine("Maks. długość danych dodatkowych radia - " + radio_model.ExtraMaxLen + "<br>");
        Console.WriteLine("Wzorzec regex danych dodatkowych radia - " + radio_model.ExtraRegexPattern() + "<br>");
        Console.WriteLine("<br>");
    }
}
catch (RadioApiException ex)
{
    if (ex.ErrorCode == RadioErrors.InvalidLicense)
        Console.WriteLine("Nieprawidłowy klucz licencji!");
    else
        Console.WriteLine($"Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {ex.ErrorCode}).");
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia.
 *
 * Pobierz parametry wybranego kalkulatora radiowego.
 *
 * Wersja      : v1.1.6
 * Język     : Go
 * Autor       : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	radiocodecalculator "github.com/PELock/Radio-Code-Calculator-Go"
)

func main() {
	client := radiocodecalculator.New("ABCD-ABCD-ABCD-ABCD")
	errCode, model, err := client.Info(context.Background(), "ford-m-series")
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	switch errCode {
	case radiocodecalculator.ErrorSuccess:
		fmt.Printf("Model radia name - %s\n", model.Name)
		fmt.Printf("Maks. długość numeru seryjnego radia - %d\n", model.SerialMaxLen)
		fmt.Printf("Wzorzec regex numeru seryjnego radia - %s\n", model.SerialRegexPattern())
		if model.ExtraMaxLen > 0 {
			fmt.Printf("Maks. długość danych dodatkowych radia - %d\n", model.ExtraMaxLen)
			fmt.Printf("Wzorzec regex danych dodatkowych radia - %s\n", model.ExtraRegexPattern())
		}
	case radiocodecalculator.ErrorInvalidLicense:
		fmt.Println("Nieprawidłowy klucz licencji!")
	default:
		fmt.Printf("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu %d).\n", errCode)
	}
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * Pobierz parametry wybranego kalkulatora radiowego.
 *
 * Wersja        : v1.1.6
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.pelock.radiocode.RadioApiResult;
import com.pelock.radiocode.RadioCodeCalculator;
import com.pelock.radiocode.RadioErrors;
import com.pelock.radiocode.RadioModel;

public class RadioCodeCalculatorInfo {

  public static void main(String[] args) throws Exception {
    RadioCodeCalculator client = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");
    RadioApiResult result = client.info("ford-m-series");

    if (result.getError() == RadioErrors.SUCCESS) {
      RadioModel radioModel = result.getModel();
      System.out.println("Model radia name - " + radioModel.name);
      System.out.println("Maks. długość numeru seryjnego radia - " + radioModel.serialMaxLen);
      System.out.println("Wzorzec regex numeru seryjnego radia - " + radioModel.serialRegexPattern());
      if (radioModel.extraMaxLen > 0) {
        System.out.println("Maks. długość danych dodatkowych radia - " + radioModel.extraMaxLen);
        System.out.println("Wzorzec regex danych dodatkowych radia - " + radioModel.extraRegexPattern());
      }
    } else if (result.getError() == RadioErrors.INVALID_LICENSE) {
      System.out.println("Nieprawidłowy klucz licencji!");
    } else {
      System.out.println("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu " + result.getError() + ").");
    }
  }
}
################################################################################
#
# Radio Code Calculator — przykład użycia interfejsu Web API.
#
# Pobierz parametry wybranego kalkulatora radiowego.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module RadioCodeCalculator

$myRadioCodeCalculator = New-RadioCodeCalculator -ApiKey 'ABCD-ABCD-ABCD-ABCD'
$apiError, $radioModel = $myRadioCodeCalculator.Info('ford-m-series')

if ($apiError -eq [RadioErrors]::SUCCESS) {
    Write-Host ("Model radia name - {0}" -f $radioModel.name)
    Write-Host ("Maks. długość numeru seryjnego radia - {0}" -f $radioModel.serial_max_len)
    Write-Host ("Wzorzec regex numeru seryjnego radia - {0}" -f $radioModel.serial_regex_pattern())
    if ($radioModel.extra_max_len -gt 0) {
        Write-Host ("Maks. długość danych dodatkowych radia - {0}" -f $radioModel.extra_max_len)
        Write-Host ("Wzorzec regex danych dodatkowych radia - {0}" -f $radioModel.extra_regex_pattern())
    }
}
elseif ($apiError -eq [RadioErrors]::INVALID_LICENSE) {
    Write-Host 'Nieprawidłowy klucz licencji!'
}
else {
    Write-Host ("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {0})." -f $apiError)
}
# frozen_string_literal: true

###############################################################################
#
# Radio Code Calculator — parametry kalkulatora
#
# Wersja        : v1.1.6
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "radio-code-calculator"

error, radio_model = RadioCodeCalculator.new("ABCD-ABCD-ABCD-ABCD").info("ford-m-series")
if error == RadioErrors::SUCCESS
  puts "Model radia name - #{radio_model.name}"
  puts "Maks. długość numeru seryjnego radia - #{radio_model.serial_max_len}"
  puts "Wzorzec regex numeru seryjnego radia - #{radio_model.serial_regex_pattern}"
  if radio_model.extra_max_len.positive?
    puts "Maks. długość danych dodatkowych radia - #{radio_model.extra_max_len}"
    puts "Wzorzec regex danych dodatkowych radia - #{radio_model.extra_regex_pattern}"
  end
elsif error == RadioErrors::INVALID_LICENSE
  warn "Nieprawidłowy klucz licencji!"
else
  warn "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu #{error})."
end
#!/usr/bin/env bash

###############################################################################
#
# Radio Code Calculator — przykład użycia interfejsu REST.
#
# W tym przykładzie odczytamy limity jednego kalkulatora radiowego.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# parametry dla ford-m-series
#
# Treść JSON:
#
# serialMaxLen        - maximum serial length
# serialRegexPattern  - serial patterns per language
# extraMaxLen         - maximum extra-field length
# extraRegexPattern   - extra-field patterns per language

curl -sS \
  -H "Authorization: Bearer ${API_KEY}" \
  "https://www.pelock.com/api/radio-code-calculator/v1/radios/ford-m-series"

Sprawdzanie klucza aktywacyjnego

Sprawdzając status klucza aktywacyjnego, uzyskamy informacje o właścicielu licencji, jej typie oraz dacie wygaśnięcia licencji.

<?php declare(strict_types=1);

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
 *
 * Wersja      : v1.1.5
 * PHP          : >= 8
 * Zależności  : cURL
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use PELock\RadioCodeCalculator\RadioCodeCalculator;
use PELock\RadioCodeCalculator\RadioErrors;

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
$myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// logowanie do usługi
//
list($error, $result) = $myRadioCodeCalculator->login();

//
// tablica result[] zawiera informacje o licencji
//
// result["license"]["activationStatus"] - True, gdy licencja jest aktywna, False przy nieprawidłowym lub wygasłym kluczu
// result["license"]["userName"] - imię i nazwisko albo nazwa firmy właściciela licencji
// result["license"]["type"] - typ licencji (0 - licencja osobista, 1 - licencja firmowa)
// result["license"]["expirationDate"] - data wygaśnięcia licencji (format YYYY-MM-DD)
//
if ($error == RadioErrors::SUCCESS)
{
    echo "Status aktywacji licencji - " . ($result["license"]["activationStatus"] ? "True" : "False") . "<br>";
    echo "Właściciel licencji - " . $result["license"]["userName"];
    echo "Typ licencji - " . ($result["license"]["type"] == 0 ? "Personal" : "Company") . "<br>";
    echo "Data wygaśnięcia - " . $result["license"]["expirationDate"] . "<br>";
}
else if ($error == RadioErrors::INVALID_LICENSE)
    echo "Nieprawidłowy klucz licencji!";
else
    echo "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {error}).";
#!/usr/bin/env python

###############################################################################
#
# Radio Code Calculator API — przykład użycia interfejsu Web API
#
# W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
#
# Wersja        : v1.1.0
# Język       : Python
# Autor         : Bartosz Wójcik
# Project        : https://www.pelock.com/products/radio-code-calculator
# Homepage       : https://www.pelock.com
#
###############################################################################

#
# dołącz moduł Radio Code Calculator API
#
from radio_code_calculator import *

#
# utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
#
myRadioCodeCalculator = RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD")

#
# logowanie do usługi
#
error, result = myRadioCodeCalculator.login()

#
# tablica result[] zawiera informacje o licencji
#
# result["license"]["activationStatus"] - True, gdy licencja jest aktywna, False przy nieprawidłowym lub wygasłym kluczu
# result["license"]["userName"] - imię i nazwisko albo nazwa firmy właściciela licencji
# result["license"]["type"] - typ licencji (0 - licencja osobista, 1 - licencja firmowa)
# result["license"]["expirationDate"] - data wygaśnięcia licencji (format YYYY-MM-DD)
#
if error == RadioErrors.SUCCESS:
    print(f'Status aktywacji licencji - {"True" if result["license"]["activationStatus"] else "False"}')
    print(f'Właściciel licencji - {result["license"]["userName"]}')
    print(f'Typ licencji - {"Personal" if result["license"]["type"] == 0 else "Company"}')
    print(f'Data wygaśnięcia - {result["license"]["expirationDate"]}')

elif error == RadioErrors.INVALID_LICENSE:
    print("Nieprawidłowy klucz licencji!")
else:
    print(f'Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {error}).')
"use strict";

/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
 *
 * Wersja      : v1.1.5
 * JS           : ES6
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
import { RadioCodeCalculator, RadioErrors, RadioModel, RadioModels } from "radio-code-calculator";

//
// utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
//
let myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

//
// logowanie do usługi
//
myRadioCodeCalculator.login().then((result) => {

    //
    // tablica result[] zawiera informacje o licencji
    //
    // result["license"]["activationStatus"] - True, gdy licencja jest aktywna, False przy nieprawidłowym lub wygasłym kluczu
    // result["license"]["userName"] - imię i nazwisko albo nazwa firmy właściciela licencji
    // result["license"]["type"] - typ licencji (0 - licencja osobista, 1 - licencja firmowa)
    // result["license"]["expirationDate"] - data wygaśnięcia licencji (format YYYY-MM-DD)
    //
    console.log("Status aktywacji licencji - " + (result["license"]["activationStatus"] ? "True" : "False") + "<br>");
    console.log("Właściciel licencji - " + result["license"]["userName"]);
    console.log("Typ licencji - " + (result["license"]["type"] == 0 ? "Personal" : "Company") + "<br>");
    console.log("Data wygaśnięcia - " + result["license"]["expirationDate"] + "<br>");

}).catch((error) => {

    if (error["error"] == RadioErrors.INVALID_LICENSE)
        console.log("Nieprawidłowy klucz licencji!");
    else
        console.log(`Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu ${error}).`);
});
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
 *
 * Wersja      : v1.0.0
 * Rust         : 2021
 * Zależności  : radio-code-calculator
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2026 PELock LLC
 * @license Apache-2.0
 *
 *****************************************************************************/

//
// dołącz moduł Radio Code Calculator API
//
use radio_code_calculator::{RadioCodeCalculator, RadioCodeCalculatorError, RadioErrors};

#[tokio::main]
async fn main() {
    //
    // utwórz instancję klasy Radio Code Calculator API (używamy naszego klucza aktywacyjnego)
    //
    let my_radio_code_calculator =
        RadioCodeCalculator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // logowanie do usługi
    //
    match my_radio_code_calculator.login().await {
        Ok(result) => {
            //
            // tablica result[] zawiera informacje o licencji
            //
            // result["license"]["activationStatus"] - True, gdy licencja jest aktywna, False przy nieprawidłowym lub wygasłym kluczu
            // result["license"]["userName"] - imię i nazwisko albo nazwa firmy właściciela licencji
            // result["license"]["type"] - typ licencji (0 - licencja osobista, 1 - licencja firmowa)
            // result["license"]["expirationDate"] - data wygaśnięcia licencji (format YYYY-MM-DD)
            //
            let license = &result["license"];
            println!(
                "Status aktywacji licencji - {}<br>",
                if license["activationStatus"].as_bool().unwrap_or(false) {
                    "True"
                } else {
                    "False"
                }
            );
            println!("Właściciel licencji - {}", license["userName"]);
            println!(
                "Typ licencji - {}<br>",
                if license["type"].as_i64() == Some(0) {
                    "Personal"
                } else {
                    "Company"
                }
            );
            println!(
                "Data wygaśnięcia - {}<br>",
                license["expirationDate"]
            );
        }
        Err(e) => match e {
            RadioCodeCalculatorError::ApiError(ref v) => {
                if v["error"].as_i64() == Some(RadioErrors::INVALID_LICENSE as i64) {
                    println!("Nieprawidłowy klucz licencji!");
                } else {
                    println!("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {v:?}).");
                }
            },
            RadioCodeCalculatorError::InvalidLicense => println!("Nieprawidłowy klucz licencji!"),
            RadioCodeCalculatorError::Transport(msg) => println!("Błąd połączenia: {msg}"),
        },
    }
}
/******************************************************************************
 *
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
 *
 * Wersja      : v.1.0.0
 * Język     : C#
 * Zależności  : RadioCodeCalculator (NuGet / project reference)
 * Autor       : Bartosz Wójcik (support@pelock.com)
 * Projekt      : https://www.pelock.com/products/radio-code-calculator
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/radio-code-calculator
 * @copyright Copyright (c) 2021-2024 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;

var myRadioCodeCalculator = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");

try
{
    var result = await myRadioCodeCalculator.LoginAsync();

    //
    // result zawiera informacje o licencji
    //
    // result["license"]["activationStatus"] - True, gdy licencja jest aktywna, False przy nieprawidłowym lub wygasłym kluczu
    // result["license"]["userName"] - imię i nazwisko albo nazwa firmy właściciela licencji
    // result["license"]["type"] - typ licencji (0 - licencja osobista, 1 - licencja firmowa)
    // result["license"]["expirationDate"] - data wygaśnięcia licencji (format YYYY-MM-DD)
    //
    var license = result["license"];
    var activation = license?["activationStatus"]?.GetValue<bool>() ?? false;
    var type = license?["type"]?.GetValue<int>() ?? 0;

    Console.WriteLine("Status aktywacji licencji - " + (activation ? "True" : "False") + "<br>");
    Console.WriteLine("Właściciel licencji - " + license?["userName"]?.ToString());
    Console.WriteLine("Typ licencji - " + (type == 0 ? "Personal" : "Company") + "<br>");
    Console.WriteLine("Data wygaśnięcia - " + license?["expirationDate"]?.ToString() + "<br>");
}
catch (RadioApiException ex)
{
    if (ex.ErrorCode == RadioErrors.InvalidLicense)
        Console.WriteLine("Nieprawidłowy klucz licencji!");
    else
        Console.WriteLine($"Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {ex.ErrorCode}).");
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia.
 *
 * Sprawdzanie klucza aktywacyjnego.
 *
 * Wersja      : v1.1.6
 * Język     : Go
 * Autor       : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	radiocodecalculator "github.com/PELock/Radio-Code-Calculator-Go"
)

func main() {
	client := radiocodecalculator.New("ABCD-ABCD-ABCD-ABCD")
	errCode, result, err := client.Login(context.Background())
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if errCode == radiocodecalculator.ErrorInvalidLicense {
		fmt.Println("Nieprawidłowy klucz licencji!")
		os.Exit(1)
	}
	if errCode != radiocodecalculator.ErrorSuccess {
		fmt.Printf("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu %d).\n", errCode)
		os.Exit(1)
	}
	license, _ := result["license"].(map[string]any)
	fmt.Println("Status aktywacji licencji -", license["activationStatus"])
	fmt.Println("Właściciel licencji -", license["userName"])
	fmt.Println("Typ licencji -", license["type"])
	fmt.Println("Data wygaśnięcia -", license["expirationDate"])
}
/******************************************************************************
 * Radio Code Calculator API — przykład użycia interfejsu Web API
 *
 * Sprawdzanie klucza aktywacyjnego.
 *
 * Wersja        : v1.1.6
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.fasterxml.jackson.databind.JsonNode;
import com.pelock.radiocode.RadioApiResult;
import com.pelock.radiocode.RadioCodeCalculator;
import com.pelock.radiocode.RadioErrors;

public class RadioCodeCalculatorLogin {

  public static void main(String[] args) throws Exception {
    RadioCodeCalculator client = new RadioCodeCalculator("ABCD-ABCD-ABCD-ABCD");
    RadioApiResult result = client.login();

    if (result.getError() == RadioErrors.SUCCESS) {
      JsonNode license = result.getBody().path("license");
      System.out.println("Status aktywacji licencji - " + license.path("activationStatus").asText());
      System.out.println("Właściciel licencji - " + license.path("userName").asText());
      System.out.println("Typ licencji - " + license.path("type").asText());
      System.out.println("Data wygaśnięcia - " + license.path("expirationDate").asText());
    } else if (result.getError() == RadioErrors.INVALID_LICENSE) {
      System.out.println("Nieprawidłowy klucz licencji!");
    } else {
      System.out.println("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu " + result.getError() + ").");
    }
  }
}
################################################################################
#
# Radio Code Calculator — przykład użycia interfejsu Web API.
#
# Sprawdź stan klucza aktywacyjnego.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module RadioCodeCalculator

$myRadioCodeCalculator = New-RadioCodeCalculator -ApiKey 'ABCD-ABCD-ABCD-ABCD'
$apiError, $result = $myRadioCodeCalculator.Login()

if ($apiError -eq [RadioErrors]::SUCCESS) {
    $active = if ($result.license.activationStatus) { 'True' } else { 'False' }
    $type = if ($result.license.type -eq 0) { 'Personal' } else { 'Company' }
    Write-Host ("Status aktywacji licencji - {0}" -f $active)
    Write-Host ("Właściciel licencji - {0}" -f $result.license.userName)
    Write-Host ("Typ licencji - {0}" -f $type)
    Write-Host ("Data wygaśnięcia - {0}" -f $result.license.expirationDate)
}
elseif ($apiError -eq [RadioErrors]::INVALID_LICENSE) {
    Write-Host 'Nieprawidłowy klucz licencji!'
}
else {
    Write-Host ("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu {0})." -f $apiError)
}
# frozen_string_literal: true

###############################################################################
#
# Radio Code Calculator — logowanie
#
# Wersja        : v1.1.6
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "radio-code-calculator"

error, result = RadioCodeCalculator.new("ABCD-ABCD-ABCD-ABCD").login
if error == RadioErrors::SUCCESS
  license = result["license"]
  puts "Status aktywacji licencji - #{license["activationStatus"]}"
  puts "Właściciel licencji - #{license["userName"]}"
  puts "Typ licencji - #{license["type"]}"
  puts "Data wygaśnięcia - #{license["expirationDate"]}"
elsif error == RadioErrors::INVALID_LICENSE
  warn "Nieprawidłowy klucz licencji!"
else
  warn "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego (kod błędu #{error})."
end
#!/usr/bin/env bash

###############################################################################
#
# Radio Code Calculator — przykład użycia interfejsu REST.
#
# W tym przykładzie sprawdzimy klucz aktywacyjny.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# logowanie do usługi
#
# Treść JSON:
#
# license.activationStatus - true, gdy klucz jest aktywny
# license.userName         - nazwa właściciela
# license.type             - typ licencji
# license.expirationDate   - data wygaśnięcia (YYYY-MM-DD)

curl -sS \
  -H "Authorization: Bearer ${API_KEY}" \
  "https://www.pelock.com/api/radio-code-calculator/v1/license"

Masz pytania?

Jeśli masz jakieś pytania dotyczące Kalkulatora Kodów Do Radia oraz jego pakietów SDK, masz jakieś uwagi lub pytania dotyczące generowania kodów radiowych, albo coś jest niejasne, napisz do mnie, chętnie odpowiem na każde Twoje pytanie.