js-klikvet-logic-worker 2.1.5 → 2.3.18

package/worker.mjs

@@ -0,0 +1,1353 @@
+//@ts-check
+
+const DEFAULT_SERVICE_NAME = 'klikvet'
+
+/** @type {any} */
+import assert  from 'assert'
+import * as logic  from 'cry-klikvet-logic'
+import clonedeep  from 'lodash.clonedeep'
+import packageJson from './package.json' assert { type: "json" }
+import makeDir  from 'make-dir'
+import fs  from 'fs'
+import path  from 'path'
+import { Worker, Client }  from 'cry-ebus2'
+import { Mongo } from 'cry-db'
+import { arrayToObject, dedup, Log, serialize } from 'cry-helpers'
+
+let client = null
+
+let log = new Log(['KLIKVET'])
+let mongo = undefined
+
+/** @typedef {import('cry-klikvet-logic').Blagovnica} Blagovnica */
+/** @typedef {import('cry-klikvet-logic').Nastavitve} Nastavitve */
+/** @typedef {import('cry-klikvet-logic').ZalogaDbAccessor} ZalogaDbAccessor */
+/** @typedef {import('cry-klikvet-logic').Racun} Racun */
+
+function round(num, dec = 2)
+{
+    return Number(num.toFixed(dec))
+};
+
+/**
+ * 
+ * @param {string} tenant 
+ * @returns {Promise<Nastavitve>}
+ */
+async function dbNastavitve(tenant) {
+    mongo.setDb(tenant)
+    return (/** @type {Nastavitve}  */ (await mongo.findOne("nastavitve",{})))
+}
+
+async function dbFindById(db, collection, _id)
+{
+    mongo.setDb(db)
+    return await mongo.findById(collection,_id)
+}
+
+async function dbFind(db, collection, query, opts) {
+    mongo.setDb(db)
+    return await mongo.find(collection,query, opts)
+}
+
+async function dbUpdateById(db, collection, _id, update) {
+    mongo.setDb(db)
+    return await mongo.updateOne(collection, { _id },update)
+}
+
+async function dbUpsert(db, collection, _id, update) {
+    mongo.setDb(db)
+    return await mongo.upsert(collection, { _id }, update)
+}
+
+async function posljiSmsNarocenemu(data, n, gsm) {
+    
+    let res = (await client.requestPromise('sms', {
+        operation: 'send',
+        text: n.smsText,
+        sender: n.posiljatelj,
+        gsm: gsm || n.narocen.opomnikStevilka,
+    }, null, 2000));
+
+    let smsRes = res?.data?.res;
+    let sentOk = smsRes?.Packet.Body?.Item?.Content === "Message sent";
+    let napaka = !sentOk ? smsRes?.Packet.Body?.Item?.Content : undefined;;
+    let _id = smsRes?.Packet.Header?.ID;
+    console.dir(smsRes, { depth: 20 });
+
+    if (_id) {
+        mongo.setDb(data.tenant)
+        await mongo.upsert("smsOddaje", { _id }, {
+            besedilo: n.smsText,
+            datum: new Date(),
+            status: sentOk ? "oddano" : "napaka",
+            napaka,
+            nacin: data.nacin,
+            kdo: data.kdo,
+            gsm,
+            narocen_id: n.narocen._id,
+            pacient_id: n.narocen.pacient_id,
+            stranka_id: n.narocen.stranka_id,
+            zaKdaj: n.zaKdaj,
+        })
+        if (data.nacin === "samodejno") {
+            await mongo.upsert("naroceni", { _id: n.narocen._id },
+                napaka ? { smsOddaja_napaka: { _id, napaka, } } : { smsOddaja_id: _id, }
+            );
+        }
+    }
+    return smsRes;
+}
+async function posljiSmsNCepljenjemu(data, n, gsm) {
+    let res = (await client.requestPromise('sms', {
+        operation: 'send',
+        text: n.smsText,
+        sender: n.posiljatelj,
+        gsm: gsm || n.cepljenje.opomnikStevilka,
+    }, null, 2000));
+
+    let smsRes = res?.data?.res;
+    let sentOk = smsRes?.Packet.Body?.Item?.Content === "Message sent";
+    let napaka = !sentOk ? smsRes?.Packet.Body?.Item?.Content : undefined;;
+    let _id = smsRes?.Packet.Header?.ID;
+    console.dir(smsRes, { depth: 20 });
+
+    if (_id) {
+        mongo.setDb(data.tenant)
+        await mongo.upsert("smsOddaje", { _id }, {
+            besedilo: n.smsText,
+            datum: new Date(),
+            status: sentOk ? "oddano" : "napaka",
+            napaka,
+            nacin: data.nacin,
+            kdo: data.kdo,
+            gsm,
+            cepljenje_id: n.cepljenje._id,
+            pacient_id: n.pacient._id,
+            stranka_id: n.pacient.stranka_id,
+            zaKdaj: n.zaKdaj,
+        })
+        if (data.nacin === "samodejno" && !napaka) {
+            if (!napaka) n.pacient.cepljenja[n.cepljenje._id].smsOddaja_id = _id;
+            else n.pacient.cepljenja[n.cepljenje._id].smsOddaja_napaka = { napaka, _id  };
+            await mongo.upsert("pacienti", { _id: n.pacient._id }, {
+                cepljenja: n.pacient.cepljenja
+            })
+        }
+    }
+    return smsRes;
+}
+
+async function razknjiziRacun(data) 
+{
+    let racun = await dbFindById(data.tenant, "racuni", data._id);
+    let nastavitve = await dbNastavitve(data.tenant);
+    mongo.setDb(data.tenant)
+    mongo.setAudit({ tenant: data.tenat, app: "klikvet/razknjiziRacun" })
+    await logic.spremeniZalogoNaPodlagiRacuna(racun, nastavitve, mongo)
+    await pobrisiZalogoNaDan(data.tenant, [racun.datum])
+    return { ok: true }
+}
+
+async function razknjiziRacune(data) 
+{
+    mongo.setDb(data.tenant)
+    mongo.setAudit({ tenant: data.tenant, app: "klikvet/razknjiziRacune" })
+
+    let dni = 14 * 24 * 60 * 60 * 1000;     // 14 dni
+    let od = new Date(new Date().valueOf() - dni);
+    let racuni = await mongo.find("racuni", { datum: { $gte: od },razknjizen: false }  , {});
+    let nastavitve = await dbNastavitve(data.tenant);
+    let datumi = []
+    for await (let racun of racuni) {
+        datumi.push(racun.datum)
+        await logic.spremeniZalogoNaPodlagiRacuna(racun, nastavitve, mongo)
+        console.log('z zamikom razknjižen račun št. ',racun.stevilka);
+    }
+    await pobrisiZalogoNaDan( data.tenant, datumi )
+    return { ok: true, racuni }
+}
+
+async function pobrisiZalogoNaDan(db, datumi) {
+    try {
+        if (!datumi) return;
+        if (!Array.isArray(datumi)) datumi = []
+        if (!datumi.length) return;
+        let od = new Date(Math.min(...datumi.map(d => d.valueOf())) - 24 * 60 * 60 * 1000);
+        mongo.setDb(db)
+        mongo.setAudit({ tenant: db, app: "klikvet/pobrisiZalogoNaDan" })
+
+        if (od.valueOf() > 0) await mongo.hardDelete("zalogaNaDan", { datum: { $gte: od } });
+        else console.log("pobrisiZalogoNaDan napačni datumi", datumi)
+    } catch (err) {
+        console.log("pobrisiZalogoNaDan error", err);
+    }
+}
+
+async function skladisceLokacije(lokacija_id, tenant) {
+    let vsa = await dbFind(tenant, "skladisca", { _deleted: { $exists: false }});
+    let moje = vsa.filter(s => s.lokacija_id.toString() === lokacija_id);
+    if (moje.length === 0) moje = vsa;
+    if (moje.length == 0) console.error("Ni skladišča za lokacijo", lokacija_id);
+    if (moje.length > 1) console.error("Več skladišč za lokacijo", lokacija_id);
+    return moje?.[0]
+}
+
+async function porabeZaDobavnice(data) {
+    
+    let nastavitve = await dbNastavitve(data.tenant);
+    let od = new Date(new Date().valueOf() - 365 * 24 * 60 * 60 * 1000);
+
+    let nerazknijzene = await dbFind(data.tenant, "dobavnice",
+        { datumDokumenta: { $gte: od }, 
+        status: { $in: ["izdana","zaračunana"] }, poraba_id: { $exists: false }, _deleted: { $exists: false } },
+        { sort: { datumDokumenta: 1 } }
+    );
+    
+    let artikel_ids = dedup(nerazknijzene.map(d => d.postavke.map(p => p.artikel_id?.toString())).flat());
+    
+    let artikli = await dbFind(data.tenant, "artikli", {
+        _id: { $in: artikel_ids }
+    })
+    console.log('artikli',artikli);
+    
+    let vse = 0, razknjizene = 0
+    let napake = []
+    for await (let dobavnica of nerazknijzene) {
+        if (!dobavnica.lokacija_id) console.error("dobavnica nima lokacije", dobavnica._id, dobavnica.stevilka)
+        try {
+            let skladisce_id = dobavnica.skladisce_id || (await skladisceLokacije(dobavnica.lokacija_id, data.tenant));
+            vse++
+            let poraba = await logic.porabaZaDobavnico({
+                dobavnica,
+                nastavitve,
+                skladisce_id,
+                lokacija_id: dobavnica.lokacija_id,
+                username: data.username,
+                artikli: arrayToObject(artikli, "_id"),
+            });
+            
+            if (poraba) {
+                poraba.status = "zaključena"
+                let p = await dbUpsert(data.tenant, "odprteBlagovnice", poraba._id, poraba);
+                console.log('p',p);
+                
+                await dbUpsert(data.tenant, "dobavnice", dobavnica._id, { poraba_id: p._id, poraba_sestavljena: new Date() });
+            }
+            if (poraba === null) {
+                await dbUpsert(data.tenant, "dobavnice", dobavnica._id, { poraba_id: null, poraba_preskocena: new Date() });
+            }
+            razknjizene++
+        } catch (err) {
+            napake.push(err)
+        }
+    }
+    return { ok: vse === razknjizene, vse, razknjizene, napake }
+}
+
+async function razknjiziBlagovnice(data) 
+{
+    let od = new Date(new Date().valueOf() - 60 * 24 * 60 * 60 * 1000);
+   
+    // poišči tiste, ki bi morale že biti razknjižene, pa niso
+    {
+        let od = new Date(new Date().valueOf() - 3 * 60 * 24 * 60 * 60 * 1000);
+        let vpisane = await dbFind(data.tenant, "blagovnice", { datum: { $gte: od} }, { project: { _id: 1, status: 1 } });
+        let idjiVpisanih = vpisane.map(b => b._id.toString());
+        
+        let zaPovrnit = await dbFind(data.tenant, "odprteBlagovnice", { _deleted: { $ne:"hack"}, status: "zaključena",  datum: { $gte: od }, _id: { $nin: idjiVpisanih } }, { project: { status: 1, dokumentDobavitelja: 1, vrsta: 1 }});
+        
+        for await (let b of zaPovrnit) {
+            console.log("vračam blagovnico v razkljižno",data.tenant,b)
+            await dbUpsert(data.tenant, "odprteBlagovnice", b._id, { razknjizena: undefined, _deleted: undefined, _vrnjenoVRazknjizbo: new Date() });
+        }
+    }
+
+    let nerazknijzene = await dbFind(data.tenant, "odprteBlagovnice",
+        { datum: { $gte: od }, status: "zaključena", razknjizena: { $exists: false } },
+        { sort: { datum: 1 } }
+    );
+    let vse = 0, razknjizene = 0
+    let napake = []
+    for await (let dobavnica of nerazknijzene) {
+        try {
+            vse++
+            await razknjiziBlagovnico(dobavnica._id.toString(), data.tenant)
+            razknjizene++
+        } catch (err) {
+            napake.push(err)
+        }
+    }
+    return { ok: vse === razknjizene, vse, razknjizene, napake }
+}
+
+async function razknjiziDobavnice(data) {
+    let od = new Date(new Date().valueOf() - 60 * 24 * 60 * 60 * 1000)
+    let nerazknijzene = await dbFind(data.tenant, "dobavnice",
+        { datum: { $gte: od }, status: "izdana", razknjizena: { $exists: false } },
+        { sort: { datum: 1 } }
+    );
+    let vse = 0, razknjizene = 0
+    let napake = []
+    for await (let blagovnica of nerazknijzene) {
+        try {
+            vse++
+            await razknjiziDobavnico(blagovnica._id.toString(), data.tenant)
+            razknjizene++
+        } catch (err) {
+            napake.push(err)
+        }
+    }
+    return { ok: vse === razknjizene, vse, razknjizene, napake }
+}
+
+// async function razknjiziBlagovnico(_id, tenant)
+// {
+//     let nastavitve = await dbNastavitve(tenant);
+//     mongo.setDb(tenant)
+//     mongo.setAudit({ tenant, app: "klikvet/razknjiziBlagovnico/1" })
+
+//     await logic.zakljuciBlagovnico(_id, mongo);
+    
+//     /** @type {Blagovnica}} */
+//     let blagovnica = (/** @type {Blagovnica} */ await dbFindById(tenant, "blagovnice", _id))
+//     if (!blagovnica) throw new Error(`ne morem razknjižiti blagovnice, ki je ni: ${_id}, tenant ${tenant}`)
+
+//     mongo.setDb(tenant)
+//     mongo.setAudit({ tenant, app: "klikvet/razknjiziBlagovnico/2" })
+
+//     await logic.spremeniZalogoNaPodlagiBlagovnice(blagovnica, nastavitve, mongo);
+//     await pobrisiZalogoNaDan(tenant, [ blagovnica.datum ]);
+// }
+
+async function razknjiziBlagovnico(_id, tenant) {
+    mongo.setDb(tenant)
+    mongo.setAudit({ tenant, app: "klikvet/razknjiziBlagovnico" })
+
+    let blagovnica = await logic.razknjiziBlagovnico(_id, mongo);
+    return blagovnica
+}
+
+async function razknjiziDobavnico(_id, tenant) {
+    mongo.setDb(tenant)
+    mongo.setAudit({ tenant, app: "klikvet/razknjiziDobavnico" })
+    let dobavnica = await logic.razknjiziDobavnico(_id, mongo);
+    return dobavnica
+}
+
+async function registerAllInvoices(data)
+{
+    assert(data.tenant, "must specify tenant")
+
+    let err = null;
+    let napake = new Set()
+    try {
+
+        err = "Podsistem db ni dosegljiv."
+
+        mongo.setDb(data.tenant)
+        mongo.setAudit({ tenant: data.tenant, app: "klikvet/registerAllInvoices" })
+
+        let myquery = { eor: null, negotovinski: { $ne: true}, leto: { $gte: 2022 } };
+        let env = data.env || (await mongo.findOne("nastavitve", {})).okolje
+
+        let all = await mongo.find("racuni", myquery, { project: { _id: 1 }, limit: 1000, })
+        err = "Napaka pri potrjevanju računov."
+
+        let n = 0;
+        try {
+            for await (let r of all) {
+                let res = await registerInvoice({ tenant: data.tenant, env, _id: r._id.toString() }, true);
+                if (res.eor) n++;
+                if (res.fursError) napake.add(res.fursError)
+            }
+        } catch (e) {
+            err = e.message;
+            console.log('err',err);
+            throw new Error()
+        }
+
+        return { nall: all.length, nok: n, napake: [...napake] };
+        
+    } catch {
+        console.error('registerAllInvoices', err);
+        throw new Error(err);
+    }
+}
+
+async function registerCert(db,davcnaStevilka)
+{
+    let cert = (await client.requestPromise('db', {
+        operation: 'findOne',
+        db,
+        collection: "certifikati",
+        query: { davcnaStevilka }
+    }, null, 2000)).data;
+
+    let res = (await client.requestPromise('durs', { operation: 'add cert', data: { cert: cert.certBase64, password: cert.certPass } }, null, 2000)).data;
+    console.log('res',res);
+}
+
+async function registerInvoice(data, kasneje=false)
+{
+    mongo.setAudit({ tenant: data.tenant, app: "klikvet/registerInvoice"})
+    
+    assert(data._id, "must specify _id of racun")
+    assert(["error","production","test"].includes(data.env), "must specify env")
+    assert(data.tenant, "must specify tenant")
+
+    let timeoutError = "";
+    try {
+        // poišči račun
+        timeoutError = "Db podsistem se ni odzval."
+        let racun = await dbFindById(data.tenant,"racuni",data._id)
+        if (racun.negotovinski) return "negotovinski račun ne bo fiskaliziran";
+
+        let blagajna = await dbFindById(data.tenant, "blagajne", racun.blagajna_id)
+            if (!blagajna) throw new Error("cannot locate blagajna: "+racun.blagajna_id)
+        let poslovalnica = await dbFindById(data.tenant, "poslovalnice", blagajna.poslovalnica_id)
+            if (!blagajna) throw new Error("cannot locate poslovalnica: "+racun.blagajna_id)
+        let veterina = await dbFindById(data.tenant, "nastavitve", poslovalnica.veterina_id)
+        if (!veterina) throw new Error("cannot locate poslovalnica: " + poslovalnica.veterina_id)
+        if (!racun.izdalDs) throw new Error("Uporabnik verjetno nima vpisane davčne številke.")
+        
+        // če gre za popravek računa, poveži izvorni račun na ta popravek
+        if (racun.predhodniRacun && racun.predhodniRacun._id) {
+            dbUpdateById(data.tenant, "racuni", racun.predhodniRacun._id.toString(), {
+                naslednjiRacun: {
+                    _id: data._id.toString(),
+                    datum: racun.datum,
+                    stevilka: racun.stevilka,
+                }
+            })
+        }
+
+        let TaxNumber = (veterina.dsCertifikata || veterina.davcnaStevilka)
+        TaxNumber = parseInt(TaxNumber.toString().match(/\d+/));
+
+        let Invoice = {
+            TaxNumber,
+            IssueDateTime: new Date(racun.datum),
+            NumberingStructure: "B",
+            InvoiceIdentifier: {
+                BusinessPremiseID: poslovalnica.koda,
+                ElectronicDeviceID: blagajna.nazivZaIzpis,
+                InvoiceNumber: racun.stRacuna.toString(),
+            },
+            InvoiceAmount: round(racun.mpc),
+            PaymentAmount: round(racun.mpc),
+            TaxesPerSeller: [{
+                VAT: racun.davki.map(d => {
+                    return {
+                        TaxRate: round(d.dst * 100),
+                        TaxableAmount: round(d.osnova),
+                        TaxAmount: round(d.davek),
+                    }
+                })
+            }],
+            OperatorTaxNumber: Number(racun.izdalDs),
+            //ProtectedID: null,
+            SubsequentSubmit: kasneje,
+            // ReferenceInvoice: [{
+            //     ReferenceInvoiceIdentifier: {
+            //         BusinessPremiseID: "36CF",
+            //         ElectronicDeviceID: "BLAG2",
+            //         InvoiceNumber: "144"
+            //     },
+            //     ReferenceInvoiceIssueDateTime: new Date()
+            // }],
+        };
+        if (racun.predhodniRacun) {
+            let s = racun.predhodniRacun.stevilka.split("-");
+            Invoice.ReferenceInvoice = [{
+                ReferenceInvoiceIdentifier: {
+                    BusinessPremiseID: s[2],
+                    ElectronicDeviceID: s[1],
+                    InvoiceNumber: s[0],
+                },
+                ReferenceInvoiceIssueDateTime: racun.predhodniRacun.datum,
+            }];
+        }
+        let DursEnv = veterina.okolje;
+        if (DursEnv !== data.env) throw new Error(`data.env (${data.env}) !== veterina.okolje (${veterina.okolje})`);
+
+        // console.dir(Invoice, {depth:10});
+        
+        // davčno potrdi račun
+        let furs={}, napaka=""
+        try {
+
+            timeoutError = "FURS podsistem se ni odzval."
+
+            furs = (await client.requestPromise('durs', {
+                operation: 'register invoice',
+                data: { Invoice, DursEnv, tenant: data.tenant }
+            }, null, 4000)).data?.Durs;
+
+            try {
+                console.log(data.tenant, Invoice.TaxNumber, `${Invoice?.InvoiceIdentifier?.BusinessPremiseID}-${Invoice?.InvoiceIdentifier?.ElectronicDeviceID}-${Invoice?.InvoiceIdentifier?.InvoiceNumber}`, Invoice.InvoiceAmount, furs.EOR);
+            } catch (err) {
+                console.error(`err logging furs response`);
+            }
+            
+            if (furs?.error && furs.error.match(/no such file/g)) {
+                console.warn("no certificate, register it");
+                // register cert
+                timeoutError = "Samodejna registracija digitalnega potrdila furs spodletela."
+
+                await registerCert(data.tenant, Invoice.TaxNumber);
+                // re-submit invoice
+                furs = (await client.requestPromise('durs', {
+                    operation: 'register invoice',
+                    data: { Invoice, DursEnv, tenant: data.tenant }
+                }, null, 4000)).data.Durs;
+            }
+            if (furs?.error && furs.error.match(/SSL alert number 40/gi)) {
+                console.warn("certifikat potekel");
+                timeoutError = "Je digitalno potrdilo FURS pretečeno?"
+                throw new Error(furs.error)
+            } 
+            if (furs?.error && furs.error.match(/no such file/g)) {
+                console.warn("no certificate, register it");
+                // register cert
+                timeoutError = "Samodejna registracija digitalnega potrdila furs spodletela."
+
+                await registerCert(data.tenant, Invoice.TaxNumber);
+                // re-submit invoice
+                furs = (await client.requestPromise('durs', {
+                    operation: 'register invoice',
+                    data: { Invoice, DursEnv, tenant: data.tenant }
+                }, null, 4000)).data.Durs;
+            }
+
+        } catch (err) {
+            console.error("Err calling durs register.invoice", err)
+            napaka = `${timeoutError} (${err&&err.data&&err.data.message})`
+        }
+
+        napaka = napaka || furs?.error;
+        if (!napaka && (!furs?.EOR || !furs?.ZOI)) napaka = "furs sistem ni vrnil EOR ali ZOI"
+        let fursObj = napaka ? {
+            zoi: furs?.ZOI,
+            eor: furs?.EOR,
+            qr: furs?.QR,
+            fursError: `furs/račun: ${napaka}`,
+            davcnoSpodletloPrvic: racun.davcnoSpodletloPrvic || new Date(),
+            davcnoSpodletloZadnjic: new Date(),
+            davcnoSpodletloPoskusov: (racun.davcnoSpodletloPoskusov||0)+1
+        } : {
+            zoi: furs.ZOI,
+            eor: furs.EOR,
+            qr: furs.QR,
+            davcnoPotrjeno: new Date(),
+        }
+
+        // posodobi račun
+        timeoutError = "Napaka pri vpisu davčno potrjenega računa: Db podsistem se ne odziva več."
+        let updated = await dbUpdateById(data.tenant, "racuni", data._id, fursObj);
+
+        try {
+            let dir = path.join('./racuni', new Date().getFullYear().toString(), data.tenant)
+            !fs.existsSync(dir) && makeDir.sync(dir);
+            fs.writeFileSync(path.join(dir, racun.stevilka), serialize.pack(clonedeep({  ...racun, ...updated}), false));
+        } catch (err) {
+            console.log("napaka pri zapisu izdanega računa na disk",err)
+        }
+
+        return updated;
+
+    } catch (err) {
+
+        return {
+            fursError: `furs/račun: ${err.message||err}`,
+        }
+    }
+};
+
+/**
+ * Stornira račun" tako, da kreira nov odprtRacun z negativnimi postavkami.
+ * @param {string} db
+ * @param {string} id 
+ */
+async function storno(db,id)
+{
+    // poglej, če morda storno že poteka
+    
+    mongo.setDb(db)
+    mongo.setAudit({ tenant: db, app: "klikvet/storno/1" })
+
+    let obstojeci = await mongo.findOne("odprtiRacuni", { "predhodniRacun._id": id })
+    
+    //     (await client.requestPromise('db', {
+    //     operation: 'findOne',
+    //     db,
+    //     collection: 'odprtiRacuni',
+    //     query: { "predhodniRacun._id": id  }
+    // }, null, 2000)).data;
+    
+    if (obstojeci) return obstojeci;
+
+    let racun = clonedeep(await dbFindById(db, "racuni", id) );
+
+    if (!racun) throw new Error(`storno: ni računa ${id}`)
+    
+
+    // povezi racuna
+    racun.predhodniRacun = {
+        _id: racun._id,
+        stevilka: racun.stevilka,
+        datum: racun.datum
+    };
+
+    // ustvari negativne postavke
+    racun.postavke.forEach(postavka => {
+        ['kolicina', 'tpop', 'tnbc', 'tdav', 'tprc', 'tmpc'].forEach(f => {
+            postavka[f] = -postavka[f]
+        })
+    });
+
+    // ustvari negativne vsote
+    ['mpc', 'prc', 'dav', 'pop', 'nbc'].forEach(f => {
+        racun[f] = -racun[f]
+    });
+    // zbrisi polja, ki jih ne sme biti na novem računu
+
+    // odstrani polja, ki so odvec
+    
+    [   "zapSt", "stRacuna", "pripis", "izdal", "opis", "zoi", "eor", "stKopij", "stevilka",
+        "idIzdanegaRacuna", "valuta", "izdalDs", "razknjizen", "statusIzdaje", 
+        "odprt", "odprtIz", "naprava_id", "izPredracuna_id", "izPredracuna_st",
+        "izDobavnice_id", "izDobavnice_st", "datum", "zbirnik", 
+        "opomba", "fursError", "davcnoPotrjeno", "davcnoSpodletloPrvic",
+        "davcnoSpodletloZadnjic", "davcnoSpodletloPoskusov", "stKopij", "datumiKopij",
+        "navodiloStranki", "kontrola", "vCrpDatum", "vCrpKdo", "vCrp",
+        
+    ].forEach(f => {
+        delete racun[f]
+    });
+    
+    racun.datum = new Date();
+    // tole nastavi GUI
+    racun.placila = []
+    racun.davki = []
+
+    delete racun._id;
+
+    mongo.setDb(db)
+    mongo.setAudit({ tenant: db, app: "klikvet/storno/2" })
+
+    let odprtiRacun = await mongo.insert("odprtiRacuni",racun)
+        
+    //     (await client.requestPromise('db', {
+    //     operation: 'insert',
+    //     db,
+    //     collection: "odprtiRacuni",
+    //     insert: racun,
+    // }, null, 2000)).data;
+
+    return odprtiRacun;
+};
+
+
+export class KlikvetLogicWorker extends Worker {
+
+    constructor({ veterine, gsm }, opts) {
+        super(DEFAULT_SERVICE_NAME, opts)
+        assert(veterine.length)
+        client = new Client({ clientChecksBrokerWithHeartbeat: false });
+        this.veterine = veterine;
+        this.gsm = gsm;
+        console.log('this.gsm',this.gsm);
+        
+    }
+
+    /**
+     * @param {import("cry-db").Types.PublishSpec} what
+     */
+    async publishMsg(what) {
+        try {
+            await super.publish(what.channel, what.payload)
+        } catch (err) {
+            console.log('publish failed, continue working',err.message);
+            
+        }
+    }
+
+    async resetMongo() {
+        if (mongo) await mongo.close()
+        mongo = new Mongo(null)
+        mongo.useSoftDelete(true)
+        mongo.useRevisions(true)
+        mongo.useAuditing(true)
+        mongo.emitPublishEvents(true)
+        mongo.on('publish', this.publishMsg.bind(this))
+    }
+
+    async closeMongo() {
+        if (mongo) await mongo.close()
+        mongo = undefined;
+    }
+
+    async onError(err, req, opts) {
+        console.error("klikvet logic error: follow err, req, opts");
+        console.dir(err, { depth: 10 });
+        console.dir(req, { depth: 10 });
+        console.dir(opts, { depth: 10 });
+    }
+
+    async process(data) {
+        let ret
+        try {
+            await this.resetMongo()
+            ret = await this.processLogic(data);
+        } catch (err) {
+            console.log('klikvet/process error',err);
+            throw err
+        }
+
+        await this.closeMongo()
+        
+        return ret;
+    }
+
+    async processLogic(data) {
+
+        console.log(data.tenant,data.operation);
+        
+        log.debug(`klikvet worker request of type ${typeof data}`,data)
+        
+        if (data === 'ping') {
+            return 'pong';
+        }
+
+        if (data === 'ver') {
+            return packageJson.version
+        }
+        
+        if (data.operation === 'ping') {
+            return { ping: 'pong' }
+        }
+        
+        if (data.operation === 'help') {
+            return {
+                'promet': 'run aggregation for promet',
+            }
+        }
+        assert(data.operation, 'must specify operation')
+        
+        if (data.operation === 'promet-get-config') {
+            return logic.promet;
+        }
+
+        if (data.operation === 'promet-create-pipeline') {
+            assert(data.spec, 'must specify data.spec')
+            return logic.promet.createAggregationPipeline(data.spec)
+        }
+        
+        if (data.operation === 'racuni-isci-create-pipeline') {
+            assert(data.spec, 'must specify data.spec')
+            return logic.racuni.isci.createAggregationPipeline(data.spec)
+        }
+        
+        
+        assert(data.tenant, 'must specify tenant')
+         
+         if (data.operation === 'promet-exec-pipeline') {
+            assert(data.pipeline || data.spec, 'must specify data.spec or data.pipeline')
+            if (!data.pipeline) data.pipeline = await logic.promet.createAggregationPipeline(data.spec)
+            let res = await logic.promet.execPipeline(data.pipeline.pipeline || data.pipeline, data.tenant)
+            // res.pipeline = data.pipeline;
+            return res;
+        }
+
+        if (data.operation === 'racuni-isci-exec-pipeline') {
+            assert(data.pipeline || data.spec, 'must specify data.spec or data.pipeline')
+            if (!data.pipeline) data.pipeline = await logic.racuni.isci.createAggregationPipeline(data.spec)
+            let res = await logic.racuni.isci.execPipeline(data.tenant, data.pipeline.pipeline || data.pipeline)
+            //res.pipeline = data.pipeline;
+            return res;
+        }
+
+        if (data.operation === 'porocilo-racunovodji') {
+            assert(data.tenant, 'must tenant')
+            assert(data.odDne, 'must odDne')
+            assert(data.doDne, 'must doDne')
+
+            let pipeline = logic.racunovodji.createAggregationPipeline(data)
+            let podatki = await logic.racunovodji.execPipeline(pipeline.pipeline, data.tenant)
+            let prviZadnji = await logic.racunovodji.getFirstLastBills(data.tenant, pipeline.match)
+            let kategorije = await logic.racunovodji.getCategories(data.tenant, pipeline.match)
+            let racuniPravnim = data.racuniPravnim ? await logic.racunovodji.getTaxBills(data.tenant, pipeline.match) : []
+            let racuniOdlozeno = data.racuniOdlozeno ? await logic.racunovodji.getTrrBills(data.tenant, pipeline.match) : []
+            let stornirani = await logic.zakljucekBlagajne.storniraniRacuni(pipeline.match, data.tenant)
+            let placila = await logic.zakljucekBlagajne.sestevekPlacil(data.tenant, data)
+            let pred = await logic.zalogaNaDan({ datum: new Date(new Date(data.odDne).valueOf()-24*60*60*1000), tenant:data.tenant})
+            let po = await logic.zalogaNaDan({ datum: new Date(data.doDne), tenant: data.tenant })
+            let predKonsignacija = await logic.zalogaNaDan({ datum: new Date(new Date(data.odDne).valueOf() - 24 * 60 * 60 * 1000), tenant: data.tenant, samoKonsignacija: true })
+            let poKonsignacija = await logic.zalogaNaDan({ datum: new Date(data.doDne), tenant: data.tenant, samoKonsignacija: true })
+            let spremembaZaloge = await logic.spremembaZalogeZaObdobje({ ...data, poVrstah: true })
+            let spremembaKonsignacije = await logic.spremembaZalogeZaObdobje({ ...data, poVrstah: true, samoKonsignacija: true })
+            let vsotaDobav = await logic.VsotaDobavZaObdobje({ ...data })
+            
+            return { podatki, racuniOdlozeno, racuniPravnim, kategorije, stornirani, placila, zaloga: { pred, po }, konsignacija: { pred: predKonsignacija, po: poKonsignacija }, spremembaZaloge, spremembaKonsignacije, vsotaDobav, prviZadnji };
+        }
+
+        if (data.operation === 'zakljucek-blagajne') {
+            let pipeline = logic.zakljucekBlagajne.createAggregationPipeline(data)
+            let zakljucek = await logic.zakljucekBlagajne.execPipeline(pipeline.pipeline, data.tenant)
+            let stornirani = await logic.zakljucekBlagajne.storniraniRacuni(pipeline.match, data.tenant)
+            return { zakljucek, stornirani };
+        }
+
+        if (data.operation === 'moj-promet') {
+            assert(data.username, 'must specify username')
+            assert(data.odDne, 'must specify odDne')
+            assert(data.doDne, 'must specify doDne')
+
+            let pipeline = logic.mojPromet.createAggregationPipeline(data)
+            let podatki = await logic.mojPromet.execPipeline(pipeline.pipeline, data.tenant)
+            return podatki;
+        }
+
+        if (data.operation === 'prodano') {
+            assert(data.tenant, 'must specify tenant')
+            assert(data.odDne, 'must specify odDne')
+            assert(data.doDne, 'must specify doDne')
+
+            let pipeline = logic.prodano.createAggregationPipeline(data)
+            let podatki = await logic.prodano.execPipeline(pipeline.pipeline, data.tenant)
+            return podatki;
+        }
+
+        if (data.operation === 'prodano-porabljeno') {
+            assert(data.tenant, 'must specify tenant')
+            let podatki = await logic.prodanoInPorabljeno(data)
+            return podatki;
+        }
+
+        if (data.operation === 'skupine-izdelkov') {
+            let res = await dbFind(data.tenant, "skupineArtiklov", {}, { sort: { skupina:1 }})
+            return res;
+        }
+
+        if (data.operation === 'skupine-strank') {
+            let res = await dbFind(data.tenant, "skupineStrank", {}, { sort: { skupina: 1 } })
+            return res;
+        }
+
+        if (data.operation === 'stranka-info') {
+            let res = await logic.stranke.infoStranke(data.tenant, data._id || data)
+            return res;
+        }
+
+        if (data.operation === 'get-certs') {
+            let res = await logic.certs.getAll(data.tenant)
+            return res;
+        }
+
+        if (data.operation === 'get-certs-valid') {
+            let res = await logic.certs.getValid(data.tenant, data.query)
+            return res;
+        }
+
+        if (data.operation === 'furs-register-cert') {
+            assert(data.certBase64, "must specify certBase64")
+            assert(data.certPass, "must specify certPass")
+            let timeoutError = ""
+            
+            try {
+                timeoutError = "furs/cert: FURS podsistem se ni odzval."
+                let res = (await client.requestPromise('durs', { operation: 'add cert', data: { cert: data.certBase64, password: data.certPass } }, null, 2000)).data;
+                log.debug('furs-reg-cert: durs add cert returned“', res);
+                
+                timeoutError = "furs/cert: spodletelo je pisanje v bazo."
+
+                await client.requestPromise('db', {
+                    operation: 'hardDeleteOne',
+                    collection: 'certifikati',
+                    db: data.tenant,
+                    query: { serijskaStevilka: res.certSerial }
+                });
+                
+                let cert = (await client.requestPromise('db', {
+                    operation: 'upsert',
+                    collection: 'certifikati',
+                    db: data.tenant,
+                    query: { serijskaStevilka: res.certSerial },
+                    update: {
+                        certOk: true,
+                        davcnaStevilka: res.certTaxNo,
+                        podjetje: res.certName,
+                        serijskaStevilka: res.certSerial,
+                        veljaDo: res.certValidUntil,
+                        izdajatelj: res.certIssuer,
+                        certBase64: data.certBase64,
+                        certPass: data.certPass,
+                    }
+                }, null, 2000)).data;
+                log.debug('furs-reg-cert: cert saved to db', cert);
+
+                if (!cert) return {
+                    certMessage: "Pisanje v bazo je spodletelo. Ponovno dodajte potrdilo.",
+                    certOk: false,
+                }
+
+                let ret = {
+                    certOk: true,
+                    certMessage: "digitalno potrdilo sprejeto",
+                    cert,
+                    tenant: data.tenant,
+                };
+                
+                log.info("furs-reg-cert returns", ret)
+                
+                return ret;
+
+            } catch (err) {
+
+                // console.log('err',err);
+            
+                if (err.reason === "reject" && err.data.message && /Invalid password/gi.test(err.data.message)) {
+                    return {
+                        certMessage: "Napačno geslo.",
+                        certOk: false,
+                    }
+                } else if (err.reason === "timeout") {
+                    return {
+                        certMessage: timeoutError,
+                        certOk: false,
+                    }
+                } else {
+                    log.error("furs-reg-cert", err.message)
+                    return {
+                        certMessage: "furs/cert: " + (err.reason),
+                        certOk: false,
+                    }
+                }
+            }
+
+        }
+
+        if (data.operation === 'furs-remove-cert') {
+
+            
+            assert(data.certId, "must specify certId")
+            assert(data.taxNo, "must specify taxNo")
+            
+            log.debug('removing cert', data);
+
+            let result = await client.requestPromise('durs',
+                { operation: 'remove cert', data: { taxNo: data.taxNo, } }, null, 500);
+
+            log.trace('cert removed', result);
+            
+            return {
+                ok: true,
+                result: result.data
+            };
+            
+        }
+
+        if (data.operation === "furs-register-premise") {
+
+            assert(data.poslovniProstor, "must specify poslovniProstor (its _id)")
+            assert(data.Premise, "must specify Premise")
+            assert(data.DursEnv, "must specify DursEnv")
+            assert(data.tenant, "must specify tenant")
+            assert(data.taxNo, "must specify taxNo")
+            let timeoutError = ""
+
+            try {
+                timeoutError = "furs/pp: FURS podsistem se ni odzval."
+                let res = (await client.requestPromise('durs', {
+                    operation: 'register premise',
+                    data: { Premise: data.Premise, DursEnv: data.DursEnv, tenant: data.tenant, }
+                }, null, 2000)).data;
+                log.debug('furs-register-premise: durs register premise returned', res);
+
+                if (res.success === false && /ENOENT\: no such file or directory/.test(res.error)) {
+                    // no cert, try to register it
+                    let certData = (await client.requestPromise('db', {
+                        operation: 'findOne',
+                        collection: 'certifikati',
+                        db: data.tenant,
+                        query: { davcnaStevilka: Number(data.taxNo) }
+                    })).data;
+                    if (!certData) return {
+                        success: false,
+                        message: `Digitalno potrdilo za ${data.taxNo} ni registrirano niti ga ni v bazi.`
+                    }
+                    let certRes = (await client.requestPromise('durs', { operation: 'add cert', data: { cert: certData.certBase64, password: certData.certPass } }, null, 2000)).data;
+                    log.trace("... certRes", certRes)
+                    if (!certRes || !certRes.certSerial) return {
+                        success: false,
+                        message: `Ponovna namestitev digitalnega potrdila ${data.taxNo} je spodletela.`
+                    }
+
+                    res = (await client.requestPromise('durs', {
+                        operation: 'register premise',
+                        data: { Premise: data.Premise, DursEnv: data.DursEnv }
+                    }, null, 2000)).data;
+                    log.debug('furs-register-premise: durs register premise RETRY returned', res);
+                }
+
+                if (!res.success) return res;
+
+                timeoutError = "furs/pp: spodletelo je pisanje v bazo."
+
+                let dbres = (await client.requestPromise('db', {
+                    operation: 'upsert',
+                    collection: 'poslovalnice',
+                    db: data.tenant,
+                    query: { _id: data.poslovniProstor },
+                    update: {
+                        potrditevFurs: JSON.stringify(res.result)
+                    }
+                }, null, 2000)).data;
+                log.debug('furs-register-premise: premise saved to db', dbres);
+
+                if (!dbres) return {
+                    message: "Pisanje v bazo je spodletelo. Ponovno prijavite poslovni prostor.",
+                    success: false,
+                }
+
+                let ret = {
+                    success: true,
+                    message: "poslovni prostor je prijavljen FURS",
+                    poslovalnica: dbres
+                };
+
+                log.info("furs-registger-premise returns", ret)
+
+                return ret;
+
+            } catch (err) {
+
+                // console.log('err', err);
+
+                if (err.reason === "reject" && err.data.message && /Invalid password/gi.test(err.data.message)) {
+                    return {
+                        message: "Napačno geslo.",
+                        success: false,
+                    }
+                } else if (err.reason === "timeout") {
+                    return {
+                        message: timeoutError,
+                        success: false,
+                    }
+                } else {
+                    log.error("furs-register-premise", err.message)
+                    return {
+                        message: "furs/pp: " + (err.message || err.data && err.data.message),
+                        success: false,
+                    }
+                }
+            }
+        }
+
+        if (data.operation === "furs-register-invoice") {
+            let res = await registerInvoice(data);
+            setTimeout( async () => {
+                await this.resetMongo();
+                await registerAllInvoices(data);
+                await razknjiziRacune(data);
+                await this.closeMongo();
+            },2000);
+            return res
+        };
+        
+        if (data.operation === "furs-register-all-invoices") {
+            let all = await registerAllInvoices(data);
+            setTimeout(async () => {
+                await this.resetMongo();
+                await razknjiziRacune(data);
+                await this.closeMongo();
+            },4000)
+            return all
+        };
+
+        if (data.operation === "racun-storno") {
+            assert(data.tenant, "must specify tenant")
+            assert(data, "must specify data")
+            assert(data._id, "must specify _id of the invoice")
+            return await storno(data.tenant, data.id || data._id)
+        };
+
+        if (data.operation === "razknjizi-racun") {
+            assert(data.tenant, "must specify tenant")
+            assert(data._id, "must specify _id of the invoice")
+            return await razknjiziRacun(data);
+        };
+
+        if (data.operation === "razknjizi-racune") {
+            assert(data.tenant, "must specify tenant")
+            return await razknjiziRacune(data);
+        };
+
+        if (data.operation === "razknjizi-blagovnice") {
+            assert(data.tenant, "must specify tenant")
+            return await razknjiziBlagovnice(data);
+        };
+        
+        if (data.operation === "porabe-za-dobavnice") {
+            assert(data.tenant, "must specify tenant")
+            let ret = await porabeZaDobavnice(data);
+            await razknjiziBlagovnice(data);
+            return ret;
+        };
+
+        if (data.operation === "razknjizi-dobavnico") {
+            assert(data._id, "must specify _id of Dobavnica")
+            assert(data.tenant, "must specify tenant")
+            await razknjiziDobavnico(data._id, data.tenant)
+
+            setImmediate(async () => {
+                await this.resetMongo();
+                await razknjiziDobavnice(data);
+                await this.closeMongo();
+            });
+
+            return { ok: true }
+        };
+
+        if (data.operation === "razknjizi-blagovnico") {
+            assert(data._id, "must specify _id of the Blagovnica")
+            assert(data.tenant, "must specify tenant")
+            await razknjiziBlagovnico(data._id, data.tenant)
+
+            setImmediate(async () => {
+                await this.resetMongo();
+                await razknjiziBlagovnice(data);
+                await this.closeMongo();
+            });
+
+            return { ok: true }
+        };
+
+        if (data.operation === "kartica") {
+            assert(data.tenant, "must specify tenant")
+            assert(data._id, "must specify _id of Artikel")
+            assert(data.razknjizba, "must specify razknjizba")
+
+            return await logic.karticaArtikla(data._id, data.tenant, data.razknjizba, data.skladisca_ids)
+        };
+
+        if (data.operation === "blagovnice") {
+            assert(data.tenant, "must specify tenant")
+            return await logic.poisciBlagovnice(data)
+        };
+
+        if (data.operation === "dobava-zdravil") {
+            assert(data.tenant, "must specify tenant")
+            return await logic.dobavaZdravil(data)
+        };
+
+        if (data.operation === "poraba-prodaja-zdravil") {
+            assert(data.tenant, "must specify tenant")
+            return await logic.porabaInProdajaZdravil(data)
+        };
+
+        if (data.operation === "prodaja-zdravil") {
+            assert(data.tenant, "must specify tenant") 
+            return await logic.prodajaZdravil(data)
+        };
+
+        if (data.operation === "ensure-indexes") {
+            assert(data.tenant, "must specify tenant")
+            return await logic.ensureIndexes(data.tenant)
+        };
+
+        if (data.operation === "zaloga-na-dan") {
+            assert(data.tenant, "must specify tenant")
+            console.log('data',data);
+            
+            return await logic.zalogaNaDan(data)
+        };
+
+        if (data.operation === "zaloga-po-dnevih") {
+            assert(data.tenant, "must specify tenant")
+            return await logic.zalogaPoDnevih(data)
+        };
+
+        if (data.operation === "neuporabljeno-poisci") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.od, "must specify od")
+            return await logic.poisciNeuporabljeno(data)
+        };
+
+        if (data.operation === "neuporabljeno-pobrisi") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.od, "must specify od")
+            return await logic.pobrisiNeuporabljeno(data)
+        };
+
+        if (data.operation === "sprememba-zaloge-za-obdobje") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.odDne, "must specify odDne")
+            assert(data.doDne, "must specify doDne")
+            return await logic.spremembaZalogeZaObdobje(data)
+        };
+
+        if (data.operation === "polna-inventura") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.od, "must specify od")
+            assert(data.razknjizba, "must specify razknjizba")
+            assert(data.skladisce_id, "must specify skladisce_id")
+            assert(data.izvedel, "must specify izvedel")
+            assert(data.izlociTisteBrezZaloge, "must specify izlociTisteBrezZaloge")
+            return await logic.zakljucekPolneInventureSestaviInZapisi(data);
+        };
+
+        if (data.operation === "moj-koledar") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.id, "must specify id")
+            return await logic.koledarVeterinarja(data.tenant,data.id);
+        };
+
+        if (data.operation === "sms-narocen") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.id, "must specify id")
+            return await logic.smsNarocen({ tenant: data.tenant, id: data.id });
+        };
+
+        if (data.operation === "poslji-sms-narocenemu") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.id || data.narocen, "must specify id or narocen")
+            assert(data.nacin, "must specify nacin")
+            let n = await logic.smsNarocen({ tenant: data.tenant, id: data.id, narocen: data.narocen });
+            if (!n) return undefined;
+            return await posljiSmsNarocenemu(data, n, this.gsm);
+        };
+
+        if (data.operation === "poslji-smse-narocenim") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.nacin, "must specify nacin")
+            let naroceni = await logic.smsNaroceniNaDan({ tenant: data.tenant, dan: data.dan || new Date() });;
+            if (!naroceni?.length) return undefined;
+            let res = []
+            for await (let n of naroceni) {
+                try {
+                    res.push(await posljiSmsNarocenemu(data, n, this.gsm));
+                } catch (e) {
+                    console.error("poslji-smse-narocenim resuming",e);
+                }
+            }
+            return res;
+        };
+
+        if (data.operation === "poslji-sms-cepljenja") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.cepljenje_id || data.cepljenje, "must specify cepljenje_id or cepljenje")
+            assert(data.pacient_id, "must specify pacient_id")
+            assert(data.nacin, "must specify nacin")
+            let n = await logic.smsCepljen({ tenant: data.tenant, cepljenje_id: data.cepljenje_id, pacient_id: data.pacient_id, cepljenje: data.cepljenje });
+            if (!n) return undefined;
+            return await posljiSmsNCepljenjemu(data, n, this.gsm);
+        };
+
+        if (data.operation === "poslji-smse-cepljenim") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.nacin, "must specify nacin")
+            let cepiti = await logic.smsCepljenjaNaDan({ tenant: data.tenant, dan: data.dan || new Date(), dniPrej: data.dniPrej });;
+            if (!cepiti?.length) return undefined;
+            let res = []
+            for await (let n of cepiti) {
+                try {
+                    res.push(await posljiSmsNCepljenjemu(data, n, this.gsm));
+                } catch (e) {
+                    console.error("poslji-smse-narocenim resuming", e);
+                }
+            }
+            return res;
+        };
+
+        if (data.operation === "seznam-cepljenj-za-sms") {
+            assert(data.tenant, "must specify tenant")
+            return await logic.smsCepljenjaNaDan({ tenant: data.tenant, dan: data.dan || new Date(), dniPrej: data.dniPrej });;
+        };
+
+
+        if (data.operation === "seznam-narocenih-za-sms") {
+            assert(data.tenant, "must specify tenant")
+            return await logic.smsNaroceniNaDan({ tenant: data.tenant, dan: data.dan || new Date() });;
+        };
+
+        if (data.operation === "potrditev-brejosti") {
+            assert(data.tenant, "must specify tenant")
+            assert(data._id, "must specify _id")
+            assert(data.kdo, "must specify kdo")
+            let osemenitevGoveda = await dbFindById(data.tenant || data.db, "osemenitevGoveda", data._id);
+            if (osemenitevGoveda) {
+                let update = logic.updatePotrditevBrejosti(osemenitevGoveda, data.breja, data.kdo);
+                return await dbUpdateById(data.tenant || data.db, "osemenitevGoveda", data._id, update)
+            }
+            return undefined
+        }
+
+        if (data.operation === "v-presusitev") {
+            assert(data.tenant, "must specify tenant")
+            assert(data._id, "must specify _id")
+            assert(data.kdo, "must specify kdo")
+            let osemenitevGoveda = await dbFindById(data.tenant || data.db, "osemenitevGoveda", data._id);
+            if (osemenitevGoveda) {
+                let update = logic.updatePresusitve(osemenitevGoveda, data.presusitev, data.kdo);
+                return await dbUpdateById(data.tenant || data.db, "osemenitevGoveda", data._id, update)
+            }
+            return undefined
+        }
+
+        if (data.operation === "status-osemenitve") {
+            assert(data.tenant, "must specify tenant")
+            assert(data._id, "must specify _id")
+            assert(data.kdo, "must specify kdo")
+            let osemenitevGoveda = await dbFindById(data.tenant || data.db, "osemenitevGoveda", data._id);
+            if (osemenitevGoveda) {
+                let update = logic.updateStatusOsemenitve(osemenitevGoveda, data.status, data.kdo);
+                return await dbUpdateById(data.tenant || data.db, "osemenitevGoveda", data._id, update)
+            }
+            return undefined
+        }
+
+        if (data.operation === "opomba-rejca-osemenitve") {
+            assert(data.tenant, "must specify tenant")
+            assert(data._id, "must specify _id")
+            assert(data.kdo, "must specify kdo")
+            let osemenitevGoveda = await dbFindById(data.tenant || data.db, "osemenitevGoveda", data._id);
+            if (osemenitevGoveda) {
+                let update = logic.updateOpombeRejca(osemenitevGoveda, data.opomba, data.kdo);
+                return await dbUpdateById(data.tenant || data.db, "osemenitevGoveda", data._id, update)
+            }
+            return undefined
+        }
+
+        if (data.operation === "podatki-rejca") {
+            assert(data.tenant, "must specify tenant")
+            assert(data.rejciGeslo, "must specify rejciGeslo")
+            assert(data.rejciKoda, "must specify rejciKoda")
+            return await logic.podatkiRejca(data);
+        };
+
+        if (data.operation === "zaracunaj-dobavnice") {
+            assert(data.tenant, "must specify tenant")
+	        assert(data.dobavnice_ids, "must specify dobavnice_ids");
+	        assert(data.lokacija_id, "must specify lokacija_id");
+	        assert(data.naprava_id, "must specify naprava_id");
+	        assert(data.izdal, "must specify izdal");
+            return await logic.zaracunajDobavnice(data);
+        };
+
+        if (data.operation === "anonimiziraj-podatke") {
+            assert(data.tenant, "must specify tenant")
+            assert(["demo", "demo2","dev","test"].includes(data.tenant), "cnly valid for demo, dev, test");
+            assert(data.letNazaj, "must specify letNazaj");
+            
+            return await logic.anonimizirajPodatke(logic.createMongoForAnonimizacija(data.tenant), parseInt(data.letNazaj.toString()||"1"));
+        };
+
+        assert(false, 'unsupported operation ' + data.operation)
+    }
+
+}
+
+
+