### Performing Backend Queries with KpKysely (C++)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Illustrates how to use the `KpKysely` class for making HTTP-style queries to the backend (SQLite or cloud). It shows examples of GET and POST requests, handling responses via signals, and adding attributes to queries. Requires Qt framework.

```cpp
// GET-kysely tositteen hakemiseen
KpKysely* kysely = kpk("/tositteet/123", KpKysely::GET);
connect(kysely, &KpKysely::vastaus, this, [](QVariant* data) {
    QVariantMap tosite = data->toMap();
    qDebug() << "Tosite:" << tosite.value("otsikko").toString();
    qDebug() << "Päivämäärä:" << tosite.value("pvm").toDate();
});
kysely->kysy();

// POST-kysely uuden tositteen tallentamiseen
KpKysely* tallennus = kpk("/tositteet", KpKysely::POST);
QVariantMap tositeData;
tositeData.insert("pvm", QDate::currentDate());
tositeData.insert("otsikko", "Toimistotarvikkeet");
tositeData.insert("tyyppi", 2);  // TositeTyppi::MENO

connect(tallennus, &KpKysely::lisaysVastaus, this, [](const QVariant& reply, int id) {
    qDebug() << "Tosite tallennettu, ID:" << id;
});
connect(tallennus, &KpKysely::virhe, this, [](int koodi, const QString& selitys) {
    qDebug() << "Virhe:" << koodi << selitys;
});
tallennus->kysy(tositeData);

// Kysely attribuuteilla (päivämäärärajaus)
KpKysely* listaus = kpk("/viennit", KpKysely::GET);
listaus->lisaaAttribuutti("alkupvm", QDate(2024, 1, 1));
listaus->lisaaAttribuutti("loppupvm", QDate(2024, 12, 31));
listaus->lisaaAttribuutti("tili", 3000);
listaus->kysy();
```

--------------------------------

### Installing Dependencies on Linux (Debian/Ubuntu)

Source: https://github.com/artoh/kitupiikki/blob/master/README.md

Commands to install necessary development libraries for Kitsas on Debian-based Linux distributions. This includes the Poppler PDF rendering library for Qt5 and the libzip library for handling zip archives.

```bash
sudo apt-get install libpoppler-qt5-1 libpoppler-qt5-dev
sudo apt-get install libzip-dev
```

--------------------------------

### Manage local SQLite database with SQLiteModel

Source: https://context7.com/artoh/kitupiikki/llms.txt

Demonstrates how to open, query, and create new accounting files using the SQLiteModel class. It includes examples for iterating through records, initializing new accounting data with QVariantMap, and executing database queries.

```cpp
SQLiteModel* sqlite = kp()->sqlite();

// Tietokannan avaaminen
bool onnistui = sqlite->avaaTiedosto("/polku/kirjanpito.kitsas");
if (onnistui) {
    qDebug() << "Tietokanta avattu:" << sqlite->tiedostopolku();
}

// Viimeisten kirjanpitojen lataus
sqlite->lataaViimeiset();
for (int i = 0; i < sqlite->rowCount(); i++) {
    QModelIndex idx = sqlite->index(i, 0);
    QString nimi = sqlite->data(idx, SQLiteModel::NimiRooli).toString();
    QString polku = sqlite->data(idx, SQLiteModel::PolkuRooli).toString();
    qDebug() << nimi << polku;
}

// Uuden kirjanpidon luonti
QVariantMap initials;
initials.insert("nimi", "Uusi Yritys Oy");
initials.insert("ytunnus", "1234567-8");
initials.insert("tilikartta", "yritys");
initials.insert("alkaa", QDate(2024, 1, 1));
initials.insert("paattyy", QDate(2024, 12, 31));

bool luotu = sqlite->uusiKirjanpito("/polku/uusi.kitsas", initials);

// Kyselyn luonti
KpKysely* kysely = sqlite->kysely("/tositteet", KpKysely::GET);
kysely->lisaaAttribuutti("alkupvm", QDate(2024, 1, 1));
kysely->kysy();

// Tietokannan sulkeminen
sqlite->sulje();
```

--------------------------------

### Accessing and Using the Accounting Singleton Instance (C++)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Demonstrates how to access the global accounting singleton instance `kp()` to interact with accounting data. It covers opening the database, retrieving organization details, managing accounts, cost centers/projects, and connecting to accounting change signals. Requires Qt framework.

```cpp
// Kirjanpidon avaaminen
Kirjanpito* kirjanpito = kp();
bool onnistui = kirjanpito->avaaTietokanta("/polku/kirjanpito.kitsas");

// Organisaation perustiedot
QString nimi = kp()->asetukset()->asetus("OrganisaatioNimi");
QString ytunnus = kp()->asetukset()->ytunnus();
QDate tilikausiAlkaa = kp()->tilikaudet()->tilikausiPaivalle(QDate::currentDate()).alkaa();

// Tilien käsittely
Tili myyntitili = kp()->tilit()->tiliNumerolla(3000);
qDebug() << "Tili:" << myyntitili.nimiNumero();  // "3000 Myynti"

// Kohdennusten (kustannuspaikat/projektit) käsittely
KohdennusModel* kohdennukset = kp()->kohdennukset();
Kohdennus kohdennus = kohdennukset->kohdennus(1);
qDebug() << "Kohdennus:" << kohdennus.nimi();

// Signaali kirjanpidon muutoksista
connect(kp(), &Kirjanpito::kirjanpitoaMuokattu, this, &OmaLuokka::paivitaNakyma);
```

--------------------------------

### Compiling Kitsas with QMake

Source: https://github.com/artoh/kitupiikki/blob/master/README.md

Instructions for compiling the Kitsas software using QMake, a build system commonly used with Qt projects. This process involves generating build files and then compiling the source code. It is recommended to use Qt Creator for an integrated development environment.

```bash
qmake kitupiikki.pro && make qmake_all
make
```

--------------------------------

### Managing Accounting Vouchers (Tosite) in C++

Source: https://context7.com/artoh/kitupiikki/llms.txt

Shows how to create, modify, and save accounting vouchers using the `Tosite` class. It covers initializing a new voucher, adding debit and credit entries with details like account, amount, and description, and handling voucher saving and loading events. Requires Qt framework.

```cpp
// Uuden tositteen luonti
Tosite* tosite = new Tosite(this);
tosite->nollaa(QDate::currentDate(), TositeTyyppi::MENO);
tosite->asetaOtsikko("Toimistotarvikkeet Oy Ab");
tosite->asetaKumppani("Toimistotarvikkeet Oy");

// Viennin lisääminen
TositeVienti vienti;
vienti.setPvm(QDate::currentDate());
vienti.setTili(4000);  // Ostot
vienti.setDebet(Euro::fromDouble(100.00));
vienti.setSelite("Tulostuspaperi");
vienti.setAlvKoodi(11);  // Osto kotimaa
vienti.setAlvProsentti(25.5);
tosite->viennit()->lisaa(vienti);

// Vastavienti
TositeVienti vastavienti;
vastavienti.setPvm(QDate::currentDate());
vastavienti.setTili(2871);  // Ostovelat
vastavienti.setKredit(Euro::fromDouble(100.00));
vastavienti.setSelite("Toimistotarvikkeet Oy Ab");
tosite->viennit()->lisaa(vastavienti);

// Tositteen tallennus
connect(tosite, &Tosite::talletettu, this, [](int id, int tunniste, const QDate& pvm, const QString& sarja, int tila) {
    qDebug() << "Tallennettu:" << sarja << tunniste << "/" << pvm.year();
});
tosite->tallenna(Tosite::KIRJANPIDOSSA);

// Olemassa olevan tositteen lataus
Tosite* ladattava = new Tosite(this);
connect(ladattava, &Tosite::ladattu, this, [ladattava]() {
    qDebug() << "Tosite:" << ladattava->otsikko();
    qDebug() << "Tila:" << Tosite::tilateksti(ladattava->tositetila());
});
ladattava->lataa(123);
```

--------------------------------

### Manage Products for Invoicing (C++)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Demonstrates how to load, search, create, and update products for invoicing. It covers setting product details, handling multilingual names, and adding products to invoices. Dependencies include the kp() object and TuoteModel.

```cpp
TuoteModel* tuotteet = kp()->tuotteet();

// Tuotteiden lataus
tuotteet->lataa();

// Tuotteen haku
Tuote tuote = tuotteet->tuote(1);
qDebug() << "Nimike:" << tuote.nimike();
qDebug() << "Yksikkö:" << tuote.yksikko();
qDebug() << "Hinta:" << tuote.ahinta();
qDebug() << "Tili:" << tuote.tili();
qDebug() << "ALV-koodi:" << tuote.alvkoodi();
qDebug() << "ALV-%": << tuote.alvprosentti();

// Uuden tuotteen luonti
Tuote uusi;
uusi.setNimike("Konsultointitunti");
uusi.setYksikko("h");
uusi.setAhinta(95.00);
uusi.setTili(3000);
uusi.setAlvkoodi(1);
uusi.setAlvprosentti(25.5);
uusi.setKohdennus(2);  // Projekti-ID
uusi.setKoodi("KONS-001");
tuotteet->paivitaTuote(uusi);

// Monikielinen nimike
Monikielinen& nimi = uusi.nimiKielinen();
nimi.aseta("Konsultointitunti", "fi");
nimi.aseta("Consultation hour", "en");
nimi.aseta("Konsulttimme", "sv");

// Tuotteen lisääminen laskulle
tosite->rivit()->lisaaTuote(tuote, "5", "fi", QDate::currentDate());

// Tuotteiden vienti CSV:nä
QByteArray csv = tuotteet->csv();
```

--------------------------------

### Handle user permissions with YhteysModel

Source: https://context7.com/artoh/kitupiikki/llms.txt

Shows how to verify user access rights for specific accounting actions like editing vouchers or submitting tax declarations. It also demonstrates how to extract permissions from a bitmask and perform queries through the connection model.

```cpp
YhteysModel* yhteys = kp()->yhteysModel();

// Oikeuksien tarkistus
if (yhteys->onkoOikeutta(YhteysModel::TOSITE_MUOKKAUS)) {
    qDebug() << "Tositteiden muokkaus sallittu";
}

if (yhteys->onkoOikeutta(YhteysModel::LASKU_LAHETTAMINEN)) {
    qDebug() << "Laskujen lähetys sallittu";
}

if (yhteys->onkoOikeutta(YhteysModel::ALV_ILMOITUS)) {
    qDebug() << "ALV-ilmoitus sallittu";
}

if (yhteys->onkoOikeutta(YhteysModel::TILINPAATOS)) {
    qDebug() << "Tilinpäätöksen laatiminen sallittu";
}

// Kaikki oikeudet bittikentästä
qlonglong oikeudet = yhteys->oikeudet();

// Oikeusyhdistelmät
bool kirjanpitaja = (oikeudet & YhteysModel::KIRJANPITAJA) == YhteysModel::KIRJANPITAJA;
bool omistaja = yhteys->onkoOikeutta(YhteysModel::OMISTAJA);

// Kyselyn luonti yhteyden kautta
KpKysely* kysely = yhteys->kysely("/tilikaudet", KpKysely::GET);
```

--------------------------------

### Create and Submit VAT Declaration (AlvLaskelma)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Generates a VAT declaration for a specified period, calculates taxes and discounts, and prepares the declaration for submission to the tax authorities. It utilizes C++ and Qt frameworks.

```cpp
// ALV-laskelman luonti
AlvLaskelma* laskelma = new AlvLaskelma(this, "fi");

// Laskelman valmistumissignaali
connect(laskelma, &Raportteri::valmis, this, [](RaportinKirjoittaja rk) {
    // Raportti HTML-muodossa
    QString html = rk.html();

    // Raportti PDF:nä
    QByteArray pdf = rk.pdf(true);  // taustaraidoilla
});

// Laske kauden ALV
QDate alkupvm = QDate(2024, 1, 1);
QDate loppupvm = QDate(2024, 3, 31);
laskelma->laske(alkupvm, loppupvm, AlvKausi::PITKAKUUKAUSI);

// Laskelman tulokset
Euro maksettava = laskelma->maksettava();
Euro huojennus = laskelma->huojennus();
Euro liikevaihto = laskelma->liikevaihto();

qDebug() << "Maksettava ALV:" << maksettava.display();
qDebug() << "Huojennus:" << huojennus.display();

// Ilmoituksen tallennus ja lähetys Verohallintoon
connect(laskelma, &AlvLaskelma::tallennettu, this, []() {
    qDebug() << "ALV-ilmoitus tallennettu";
});
connect(laskelma, &AlvLaskelma::ilmoitusVirhe, this, [](const QString& koodi, const QString& viesti) {
    qDebug() << "Ilmoitusvirhe:" << koodi << viesti;
});

laskelma->ilmoitaJaTallenna();  // Lähetys Verohallintoon

```

--------------------------------

### Tilikauden tiedot ja tilat C++:lla

Source: https://context7.com/artoh/kitupiikki/llms.txt

Tämä koodi näyttää, kuinka haetaan ja käsitellään tietoja kirjanpidon tilikaudesta C++:lla. Se kattaa tilikauden päivämäärien, tilinpäätöksen tilan, tunnuslukujen ja PMA-säännöstön hakemisen sekä päivämäärän kuulumisen tarkistamisen.

```cpp
// Nykyisen tilikauden haku
Tilikausi nykyinen = kp()->tilikausiPaivalle(QDate::currentDate());

// Tilikauden perustiedot
qDebug() << "Tilikausi:" << nykyinen.kausivaliTekstina();  // "1.1.2024 - 31.12.2024"
qDebug() << "Alkaa:" << nykyinen.alkaa();
qDebug() << "Päättyy:" << nykyinen.paattyy();
qDebug() << "Tunnus:" << nykyinen.kausitunnus();  // "24" tai "24B"

// Tilinpäätöksen tila
switch (nykyinen.tilinpaatoksenTila()) {
    case Tilikausi::ALOITTAMATTA:
        qDebug() << "Tilinpäätös aloittamatta";
        break;
    case Tilikausi::KESKEN:
        qDebug() << "Tilinpäätös kesken";
        break;
    case Tilikausi::VAHVISTETTU:
        qDebug() << "Tilinpäätös vahvistettu";
        break;
}

// Tunnusluvut (sentteinä)
qDebug() << "Liikevaihto:" << Euro::fromCents(nykyinen.liikevaihto()).display();
qDebug() << "Tulos:" << Euro::fromCents(nykyinen.tulos()).display();
qDebug() << "Tase:" << Euro::fromCents(nykyinen.tase()).display();

// PMA-säännöstö
switch (nykyinen.pienuus()) {
    case Tilikausi::MIKROYRITYS:
        qDebug() << "Mikroyritys";
        break;
    case Tilikausi::PIENYRITYS:
        qDebug() << "Pienyritys";
        break;
    case Tilikausi::YRITYS:
        qDebug() << "Yritys";
        break;
}

// Arkistointi
qDebug() << "Arkistoitu:" << nykyinen.arkistoitu();
qDebug() << "Arkistopolku:" << nykyinen.arkistopolku();

// Päivämäärän kuuluminen tilikauteen
if (nykyinen.kuuluuko(QDate(2024, 6, 15))) {
    qDebug() << "Päivämäärä kuuluu tilikauteen";
}
```

--------------------------------

### Perform Currency Operations with Euro

Source: https://context7.com/artoh/kitupiikki/llms.txt

The Euro class provides high-precision monetary calculations using integer-based cent storage to prevent floating-point errors. It includes methods for arithmetic, comparison, and various string formatting options.

```cpp
// Euro-instanssien luonti
Euro summa1 = Euro::fromDouble(123.45);
Euro summa2 = Euro::fromCents(12345);  // 123,45 €
Euro summa3 = Euro::fromString("1 234,56");
Euro summa4 = Euro("99,99");

// Aritmetiikka
Euro yhteensa = summa1 + summa2;
Euro erotus = summa1 - summa2;
Euro kerrottu = summa1 * 2;
Euro jaettu = summa1 / 4;

yhteensa += Euro::fromDouble(10.00);

// Vertailu
if (summa1 > Euro::Zero) {
    qDebug() << "Positiivinen summa";
}
if (summa1 == summa2) {
    qDebug() << "Summat ovat yhtäsuuret";
}

// Näyttömuodot
qDebug() << summa1.toString();     // "123.45" (piste desimaalierottimena)
qDebug() << summa1.local();        // "123,45" (lokaalin mukaan)
qDebug() << summa1.display();      // "123,45 €" (näyttömuoto)
qDebug() << summa1.cents();        // 12345 (sentteinä)
qDebug() << summa1.toDouble();     // 123.45 (double)

// QVariant-muunnokset
QVariant var = summa1.toVariant();
Euro palautettu = Euro::fromVariant(var);

// Absoluuttinen arvo
Euro negatiivinen = Euro::fromDouble(-50.00);
Euro positiivinen = negatiivinen.abs();  // 50,00 €
```

--------------------------------

### Generate Financial Reports (RaportinKirjoittaja)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Generates accounting reports in various formats including HTML, PDF, and CSV. It supports defining columns, headers, and content formatting. This class is implemented in C++ using Qt.

```cpp
// Raportin luonti
RaportinKirjoittaja rk;
rk.asetaOtsikko("Päiväkirja");
rk.asetaKausiteksti("1.1.2024 - 31.12.2024");

// Sarakkeiden määrittely
rk.lisaaPvmSarake();
rk.lisaaSarake("TOSITE");
rk.lisaaVenyvaSarake();
rk.lisaaEurosarake();
rk.lisaaEurosarake();

// Otsikkorivi
RaporttiRivi otsikko; mengetahui.lisaa("Pvm");
otsikko.lisaa("Tosite");
otsikko.lisaa("Selite");
otsikko.lisaa("Debet", 1, true);
otsikko.lisaa("Kredit", 1, true);
rk.lisaaOtsake(otsikko);

// Sisältörivit
RaporttiRivi rivi1;
rivi1.lisaa(QDate(2024, 1, 15));
rivi1.lisaa("ML 1/24");
rivi1.lisaa("Myynti Asiakas Oy");
rivi1.lisaa(Euro::fromDouble(1000.00));
rivi1.lisaa(Euro::Zero);
rk.lisaaRivi(rivi1);

// Tyhjä rivi ja yhteenveto
rk.lisaaTyhjaRivi();

RaporttiRivi yhteensa;
yhteensa.lisaa("");
yhteensa.lisaa("");
yhteensa.lisaa("Yhteensä", 1, false, true);  // Lihavoitu
yhteensa.lisaa(Euro::fromDouble(1000.00));
yhteensa.lisaa(Euro::fromDouble(1000.00));
rk.lisaaRivi(yhteensa);

// Tulostus eri muodoissa
QString html = rk.html(true);  // Linkeillä
QByteArray pdf = rk.pdf(true); // Taustaraidoilla
QByteArray csv = rk.csv();

// Tulostus paperille
QPrinter printer;
QPainter painter(&printer);
int sivuja = rk.tulosta(&printer, &painter, true, 1);
qDebug() << "Tulostettu" << sivuja << "sivua";

```

--------------------------------

### Myyntilaskun luonti ja hallinta C++:lla

Source: https://context7.com/artoh/kitupiikki/llms.txt

Tämä koodi näyttää, kuinka Lasku-luokkaa käytetään myyntilaskujen luomiseen ja hallintaan C++:lla. Se kattaa laskun perustietojen asettamisen, asiakastietojen määrittämisen, maksutavat, toistuvan laskutuksen ja laskurivien lisäämisen.

```cpp
// Uuden laskun luonti
Tosite* tosite = new Tosite(this);
    tosite->nollaa(QDate::currentDate(), TositeTyyppi::MYYNTILASKU);

Lasku& lasku = tosite->lasku();

// Laskun perustiedot
lasku.setNumero("2024001");
lasku.setLaskunpaiva(QDate::currentDate());
lasku.setErapaiva(QDate::currentDate().addDays(14));
lasku.setViite(ViiteNumero(ViiteNumero::LASKU, 2024001));

// Asiakas ja osoite
lasku.setOsoite("Asiakas Oy\nKatu 1\n00100 Helsinki");
lasku.setEmail("lasku@asiakas.fi");
lasku.setKieli("fi");

// Maksutapa ja lähetystapa
lasku.setMaksutapa(Lasku::LASKU);  // LASKU, KATEINEN, ENNAKKOLASKU, KORTTIMAKSU
lasku.setLahetystapa(Lasku::SAHKOPOSTI);  // TULOSTETTAVA, SAHKOPOSTI, VERKKOLASKU

// Lisätiedot
lasku.setViivastyskorko(11.0);
lasku.setHuomautusAika(8);
lasku.setSaate("Kiitos tilauksestanne!");
lasku.setAsiakasViite("TIL-12345");

// Toistuva lasku (kuukausittain)
lasku.setToisto(
    QDate::currentDate().addMonths(1),  // Seuraava laskutuspäivä
    1,                                    // Jakso kuukausina
    true,                                 // Hinnastolla
    QDate::currentDate().addYears(1)      // Päättymispäivä
);

// Virtuaaliviivakoodi
Iban iban("FI21 1234 5600 0007 85");
QString viivakoodi = lasku.virtuaaliviivakoodi(iban, true);  // RF-viitteellä

// Laskurivien lisääminen
TositeRivi rivi;
rivi.setNimike("Konsultointipalvelu");
rivi.setMyyntiKpl(10);
rivi.setYksikko("h");
rivi.setANetto(85.00);
rivi.setAlvKoodi(1);  // Kotimaan myynti
rivi.setAlvProsentti(25.5);
rivi.setTili(3000);
tosite->rivit()->lisaaRivi(rivi);

// Laskun tallennus ja lähetys
tosite->tallennaLasku(Tosite::VALMISLASKU);
```

--------------------------------

### Manage Cost Centers and Projects (Kohdennus)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Represents a cost center, project, or tag for allocating journal entries. It allows for creating, retrieving, and filtering these allocations. Implemented in C++ with Qt.

```cpp
KohdennusModel* model = kp()->kohdennukset();

// Kohdennuksen haku
Kohdennus kohdennus = model->kohdennus(5);

qDebug() << "ID:" << kohdennus.id();
qDebug() << "Nimi:" << kohdennus.nimi();
qDebug() << "Tyyppi:" << kohdennus.tyyppi();
qDebug() << "Alkaa:" << kohdennus.alkaa();
qDebug() << "Päättyy:" << kohdennus.paattyy();
qDebug() << "Vientejä:" << kohdennus.montakoVientia();

// Tyypin tarkistus
switch (kohdennus.tyyppi()) {
    case Kohdennus::KUSTANNUSPAIKKA:
        qDebug() << "Kustannuspaikka";
        break;
    case Kohdennus::PROJEKTI:
        qDebug() << "Projekti";
        break;
    case Kohdennus::MERKKAUS:
        qDebug() << "Merkkaus";
        break;
}

// Uuden kohdennuksen luonti
Kohdennus uusi;
uusi.asetaNimi("Uusi projekti", "fi");
uusi.asetaNimi("Nytt projekt", "sv");
uusi.asetaTyyppi(Kohdennus::PROJEKTI);
uusi.asetaAlkaa(QDate(2024, 1, 1));
uusi.asetaPaattyy(QDate(2024, 12, 31));
model->tallenna(uusi);

// Kohdennuslistaus
QList<Kohdennus> kaikki = model->kohdennukset();
QList<Kohdennus> voimassa = model->vainKohdennukset(QDate::currentDate());

// Onko kohdennuksia käytössä
if (model->projekteja()) {
    qDebug() << "Projekteja käytössä";
}
if (model->kustannuspaikkoja()) {
    qDebug() << "Kustannuspaikkoja käytössä";
}

```

--------------------------------

### Manage Accounting Entries with TositeVienti

Source: https://context7.com/artoh/kitupiikki/llms.txt

The TositeVienti class represents a single accounting entry line. It manages account assignments, debit/credit amounts, VAT details, and project allocations.

```cpp
// Yksinkertainen myyntivienti
TositeVienti myynti;
myynti.setPvm(QDate(2024, 6, 15));
myynti.setTili(3000);  // Myynti
myynti.setKredit(Euro::fromString("1250,00"));
myynti.setSelite("Konsultointipalvelu");
myynti.setAlvKoodi(1);  // Kotimaan myynti
myynti.setAlvProsentti(25.5);
myynti.setKohdennus(2);  // Projekti
myynti.setKumppani("Asiakas Oy");

// Vienti merkkauksineen (esim. useampi projekti)
TositeVienti merkitty;
merkitty.setTili(4500);
merkitty.setDebet(Euro::fromCents(50000));  // 500,00 €
QVariantList merkkaukset;
merkkaukset << 10 << 11;  // Merkkaus-ID:t
merkitty.setMerkkaukset(merkkaukset);

// Jaksotettava vienti
TositeVienti jaksotettu;
jaksotettu.setTili(4300);  // Vuokrat
jaksotettu.setDebet(Euro::fromDouble(1200.00));
jaksotettu.setSelite("Toimistovuokra Q1/2024");
jaksotettu.setJaksoalkaa(QDate(2024, 1, 1));
jaksotettu.setJaksoloppuu(QDate(2024, 3, 31));

// Vientidata JSON-muodossa
QVariant tallennettava = myynti.tallennettava();
qDebug() << "JSON:" << QJsonDocument::fromVariant(tallennettava).toJson();
```

--------------------------------

### Handle Reference Numbers (C++)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Manages Finnish and RF-format reference numbers for invoicing. This class allows for the creation of reference numbers based on invoice numbers, customer IDs, or as standard references. It also supports parsing existing reference numbers and calculating check digits.

```cpp
// Viitenumeron luonti laskun numerosta
ViiteNumero lasku_viite(ViiteNumero::LASKU, 2024001);
qDebug() << "Viite:" << lasku_viite.viite();
qDebug() << "Väleillä:" << lasku_viite.valeilla();
qDebug() << "RF-viite:" << lasku_viite.rfviite();

// Asiakaskohtainen viite
ViiteNumero asiakas_viite(ViiteNumero::ASIAKAS, 12345);

// Vakioviite
ViiteNumero vakio(ViiteNumero::VAKIOVIITE, "100");

// Viitteen parsinta
ViiteNumero parsittu("1234 5678 9012 3");
switch (parsittu.tyyppi()) {
    case ViiteNumero::LASKU:
        qDebug() << "Laskuviite, era:" << parsittu.eraId();
        break;
    case ViiteNumero::ASIAKAS:
        qDebug() << "Asiakasviite:" << parsittu.numero();
        break;
    case ViiteNumero::VIRHEELLINEN:
        qDebug() << "Virheellinen viite";
        break;
}

// Tarkasteen laskenta
QString pohja = "12345";
QString tarkaste = ViiteNumero::laskeTarkaste(pohja);
qDebug() << "Viite tarkisteella:" << pohja + tarkaste;
```

--------------------------------

### Kirjanpidon asetusten hallinta C++:lla

Source: https://context7.com/artoh/kitupiikki/llms.txt

Tämä koodi näyttää, kuinka AsetusModel-luokkaa käytetään kirjanpidon asetusten lukemiseen ja asettamiseen C++:lla. Se kattaa organisaation tietojen, boolean-arvojen, päivämäärien ja lukujen hakemisen sekä asetusten muuttumisen signaalin käsittelyn.

```cpp
AsetusModel* asetukset = kp()->asetukset();

// Organisaation tiedot
QString nimi = asetukset->asetus(AsetusModel::OrganisaatioNimi);
QString ytunnus = asetukset->ytunnus();
QString katuosoite = asetukset->asetus(AsetusModel::Katuosoite);
QString postinumero = asetukset->asetus(AsetusModel::Postinumero);
QString kaupunki = asetukset->asetus(AsetusModel::Kaupunki);

// Boolean-asetukset
bool alvVelvollinen = asetukset->onko(AsetusModel::AlvVelvollinen);
bool eriSarjaan = asetukset->onko(AsetusModel::EriSarjaan);

// Päivämäärä-asetukset
QDate tilikarttaPvm = asetukset->pvm(AsetusModel::TilikarttaPvm);

// Luku-asetukset
int alvKausi = asetukset->luku(AsetusModel::AlvKausi);  // 1=kk, 3=neljännes, 12=vuosi

// Asetusten asettaminen
asetukset->aseta(AsetusModel::OrganisaatioNimi, "Yritys Oy");
asetukset->aseta(AsetusModel::AlvVelvollinen, true);
asetukset->aseta(AsetusModel::LaskuMaksuaika, 14);

// Avainlista
QStringList kaikki = asetukset->avaimet();
QStringList laskuAsetukset = asetukset->avaimet("Lasku");

// Muutossignaali
connect(asetukset, &AsetusModel::asetusMuuttui, this, []() {
    qDebug() << "Asetuksia muutettu";
});
```

--------------------------------

### Handle IBANs (C++)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Processes and validates international bank account numbers (IBANs). This class provides functionality to create IBAN objects, retrieve basic account information like BIC and bank name, and perform validation checks, including a modulo-based integrity test. It also supports formatting IBANs with spaces.

```cpp
// IBAN:n luonti
Iban iban("FI2112345600000785");

// Perustiedot
qDebug() << "IBAN:" << iban.valeitta();    // FI2112345600000785
qDebug() << "Väleillä:" << iban.valeilla(); // FI21 1234 5600 0007 85
qDebug() << "BIC:" << iban.bic();           // NDEAFIHH
qDebug() << "Pankki:" << iban.pankki();     // Nordea

// Validointi
if (iban.isValid()) {
    qDebug() << "IBAN on kelvollinen";
}
if (iban.isEmpty()) {
    qDebug() << "IBAN on tyhjä";
}

// IBAN:n modulo-tarkistus
int modulo = Iban::ibanModulo("FI2112345600000785");
if (modulo == 1) {
    qDebug() << "IBAN läpäisee tarkistuksen";
}

// Välien lisääminen
QString muotoiltu = Iban::lisaaValit("FI2112345600000785");
qDebug() << muotoiltu;  // "FI21 1234 5600 0007 85"
```

--------------------------------

### Archive Fiscal Period (C++)

Source: https://context7.com/artoh/kitupiikki/llms.txt

Handles the electronic archiving of a fiscal period according to accounting law requirements. It generates a secure archive including vouchers, attachments, and reports, verified with SHA256. The process involves creating an Arkistoija instance for a given fiscal year and initiating the archiving process.

```cpp
// Tilikauden arkistointi
Tilikausi kausi = kp()->tilikaudet()->tilikausiPaivalle(QDate(2023, 12, 31));
Arkistoija* arkistoija = new Arkistoija(kausi, this);

// Arkistoinnin valmistuminen
connect(arkistoija, &Arkistoija::arkistoValmis, this, [](QString hakemisto) {
    qDebug() << "Arkisto luotu:" << hakemisto;
    // Arkisto löytyy esim. ~/Kitsas/Arkistot/2023/
});

// Aloita arkistointi
arkistoija->arkistoi();

// Yksittäisen tositteen HTML-runko
QVariantMap tositeData;
tositeData.insert("id", 123);
tositeData.insert("tunniste", 1);
tositeData.insert("pvm", QDate(2023, 6, 15));
tositeData.insert("sarja", "ML");
QByteArray html = arkistoija->tositeRunko(tositeData, false);  // false = ei tulostetta

// Tositteen tiedostonnimi
// Muoto: 2023-06-15_ML_0001.html
```

--------------------------------

### Manage Accounting Accounts with Tili

Source: https://context7.com/artoh/kitupiikki/llms.txt

The Tili class represents an account in the chart of accounts. It provides access to account metadata, IBAN details, VAT settings, and status flags.

```cpp
// Tilin hakeminen numerolla
TiliModel* tilit = kp()->tilit();
Tili myyntitili = tilit->tiliNumerolla(3000);

// Tilin perustiedot
qDebug() << "Numero:" << myyntitili.numero();
qDebug() << "Nimi:" << myyntitili.nimi();
qDebug() << "Nimi ja numero:" << myyntitili.nimiNumero();
qDebug() << "Tyyppi:" << myyntitili.tyyppiKoodi();

// Pankkitilin IBAN-tiedot
Tili pankkitili = tilit->tiliNumerolla(1910);
qDebug() << "IBAN:" << pankkitili.iban().valeilla();
qDebug() << "BIC:" << pankkitili.bic();
qDebug() << "Pankki:" << pankkitili.pankki();

// Tilin tyypin tarkistus
if (myyntitili.onko(TiliLaji::Tulo)) {
    qDebug() << "Tili on tulotili";
}
if (myyntitili.onko(TiliLaji::Tase)) {
    qDebug() << "Tili on tasetili";
}

// ALV-tiedot
qDebug() << "ALV-laji:" << myyntitili.alvlaji();
qDebug() << "ALV-%:" << myyntitili.alvprosentti();

// Tase-erittelyn tapa
switch (myyntitili.taseErittelyTapa()) {
    case Tili::TASEERITTELY_SALDOT:
        qDebug() << "Erittely saldoittain";
        break;
    case Tili::TASEERITTELY_TAYSI:
        qDebug() << "Täysi tase-erittely";
        break;
}

// Tilin tila
if (myyntitili.tila() == Tili::TILI_SUOSIKKI) {
    qDebug() << "Tili on suosikki";
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.