${stdout}
${stderr}` }; + } else { + if (paramnginx.firstinstall) { + // the tribes/conf.json is saved in apxtriinstall + console.log( + `\x1b[42m###########################################################################################\x1b[0m\n\x1b[42mWellcome into apxtri, you can now 'yarn dev' for dev or 'yarn startpm2' for prod or \n'yarn unittest' for testing purpose. Access to your town here \x1b[0m\x1b[32mhttp://adminapx\x1b[0m \x1b[42m \nto finish your town setup. Don't forget to set your localhost /etc/hosts by adding 127.0.0.1 adminapx or {LAN IP} adminapx . Check README's project to learn more. \x1b[0m\n\x1b[42m###########################################################################################\x1b[0m` + ); + } else { + // add website to tribe conf + } + } + }); + return res; +}; +Wwws.setssl = () => { + // Run process to change nginx conf to get a ssl +}; + +Wwws.configlist = (tribeId) => { + //if accessright R return list of conf parameter {webapp:{conf parameter}} + const res = { status: 200, data: {} }; + return res; +}; + +module.exports = Wwws; diff --git a/apxtri/models/unittest/Checkjson.js b/apxtri/models/unittest/Checkjson.js new file mode 100644 index 0000000..65a8d94 --- /dev/null +++ b/apxtri/models/unittest/Checkjson.js @@ -0,0 +1,217 @@ + /* +Unit testing +*/ +const assert = require("assert"); +const Checkjson = require("../Checkjson.js"); + +const ut = { name: "Checkjson" }; + +const schema = { + $schema: "http://json-schema.org/schema#", + title: "Dummy schema to test Checkjson.js", + description: "Checkjson is use on server as well as into a browser", + $comment: "We change schema type on the fly to simplify the test", + type: "object", + properties: { + totest: {}, + }, +}; +const testproperties = [ + { + name: "test0", + data: { totest: true }, + properties: { totest: { type: "boolean" } }, + status: 200, + }, + { + name: "test1", + data: { totest: "blabla" }, + properties: { totest: { type: "string" } }, + status: 200, + }, + { + name: "test2", + data: { totest: 123 }, + properties: { totest: { type: "string" } }, + status: 417, + }, + { + name: "test3", + data: { totest: 123.13 }, + properties: { totest: { type: "integer" } }, + status: 417, + }, + { + name: "test4", + data: { totest: 123 }, + properties: { totest: { type: "number" } }, + status: 200, + }, + { + name: "test5", + data: { totest: 12312 }, + properties: { totest: { type: "number" } }, + status: 200, + }, + { + name: "test6", + data: { totest: 12.313 }, + properties: { totest: { type: "float" } }, + status: 200, + }, + { + name: "test7", + data: { totest: "blablab sfde" }, + properties: { totest: { type: "string", minLength: 1111 } }, + status: 417, + }, + { + name: "test8", + data: { totest: "blablab sfde" }, + properties: { totest: { type: "string", minLength: 4, maxLength: 128 } }, + status: 200, + }, + { + name: "test9", + data: { totest: 12 }, + properties: { totest: { type: "integer", multipleOf: 3 } }, + status: 200, + }, + { + name: "test10", + data: { totest: 9 }, + properties: { + totest: { type: "number", minimum: -10, exclusiveMaximum: 10 }, + }, + status: 200, + }, + { + name: "test11", + data: { totest: 10 }, + properties: { + totest: { type: "number", minimum: -10, exclusiveMaximum: 10 }, + }, + status: 417, + }, + { + name: "test12", + data: { totest: "gfhrtabcdgfr" }, + properties: { totest: { type: "string", pattern: /.*abc.*/ } }, + status: 200, + }, + { + name: "test13", + data: { totest: "toto@google.com" }, + properties: { totest: { type: "string", format: "email" } }, + status: 200, + }, + { + name: "test14", + data: { totest: "Aze123@0" }, + properties: { totest: { type: "string", format: "password" } }, + status: 200, + }, + { + name: "test15", + data: { totest: "value1" }, + properties: { + totest: { type: "string", enum: ["value1", "value2", "value3"] }, + }, + status: 200, + }, + { + name: "test16", + data: { totest: ["t1", "t2"] }, + properties: { totest: { type: ["string", "number"] } }, + status: 417, + }, + { + name: "test17", + data: { totest: 12 }, + properties: { totest: { type: ["string", "number"] } }, + status: 200, + }, + { + name: "test18", + data: { totest: 100 }, + properties: { totest: { type: "integer", minimum: 50 } }, + status: 200, + }, + { + name: "test19", + data: { totest: 25 }, + properties: { totest: { type: "integer", minimum: 30 } }, + status: 417, + }, + { + name: "test20", + data: { totest: "short" }, + properties: { totest: { type: "string", minLength: 10 } }, + status: 417, + }, + { + name: "test21", + data: { totest: "long enough string" }, + properties: { totest: { type: "string", minLength: 10 } }, + status: 200, + }, + { + name: "test22", + data: { totest: 5 }, + properties: { totest: { type: "integer", maximum: 10 } }, + status: 200, + }, + { + name: "test23", + data: { totest: 15 }, + properties: { totest: { type: "integer", maximum: 10 } }, + status: 417, + }, + { + name: "test24", + data: { totest: "12345" }, + properties: { totest: { type: "string", pattern: "^[0-9]+$" } }, + status: 200, + }, + { + name: "test25", + data: { totest: "abc123" }, + properties: { totest: { type: "string", pattern: "^[0-9]+$" } }, + status: 417, + }, + { + name: "test26", + data: { totest: 9.99 }, + properties: { totest: { type: "number", exclusiveMinimum: 10 } }, + status: 417, + }, + { + name: "test27", + data: { totest: 10.01 }, + properties: { totest: { type: "number", exclusiveMinimum: 10 } }, + status: 200, + }, +]; + +ut.testproperties = (options) => { + let msg = ""; + testproperties.forEach((t) => { + schema.properties = t.properties; + const res = Checkjson.schema.data(schema, t.data); + if (res.status != t.status) { + msg = msg == "" ? "Unconsistent testproperties() name list: " : `${msg},`; + if (options.verbose) { + console.log(t); + console.log(res); + } + msg += res.err.map((e) => ` ${t.name} ${e.info}`); + } + }); + return assert.deepEqual(msg, "", msg); +}; + +ut.run = (options) => { + console.log("Test Checkjson properties"); + ut.testproperties(options); +}; +module.exports = ut; diff --git a/apxtri/models/unittest/Odmdb.js b/apxtri/models/unittest/Odmdb.js new file mode 100644 index 0000000..065cbd6 --- /dev/null +++ b/apxtri/models/unittest/Odmdb.js @@ -0,0 +1,42 @@ +/* +Unit testing +*/ +const assert = require("assert"); +const fs = require("fs-extra"); +const path = require("path"); +const Odmdb = require("../Odmdb.js"); + + +const ut = { name: "Odmdb" }; +/* +Test crud process for any object +*/ +ut.crud = (objectPathname, itm, profils) => { + // + // test if exist + // if not test create + // test to read + // test update + // test delete + const res = { status: 200, err: [] }; + return res; +}; + +const testvar={alias:"tutu", passphrase:"",privatekey:"", publickey:""} + +const testitms=[ + {objectPathname:`../..//adminapi/opjects/pagans`, + itm:{alias:'toutou', publickey:""}} +] + + + +ut.run = (options) => { + let msg="" + testitms.forEach(i=>{ + ut.crud(i) + //si erreur add msg+++ + }) + assert.deepEqual(msg, "", msg); +}; +module.exports = ut; diff --git a/apxtri/models/unittest/Pagansunittest.js b/apxtri/models/unittest/Pagansunittest.js new file mode 100644 index 0000000..9b2a3e5 --- /dev/null +++ b/apxtri/models/unittest/Pagansunittest.js @@ -0,0 +1,189 @@ +const assert = require('assert'); +const openpgp = require('openpgp'); +const Pagans = require('../Pagans'); +const dayjs = require('dayjs'); + +const ut = { name: 'Pagans' }; + +// Data +ut.test = { + tribe: "smatchit", + pagans: [ + { + alias: "unittestadminsmatchit", + passphrase: "adminsmatchitPass", + persons: { firstname: "toto", lastname: "titi", profils: ["anonymous"] }, + testprofil: "adminrecruiter", + }, + { + alias: "unittestseeker", + passphrase: "", + persons: { firstname: "toto", lastname: "titi", profils: ["anonymous"] }, + testprofil: "seeker", + }, + { + alias: "unittestrecruiter", + passphrase: "recruiterPass", + persons: { firstname: "toto", lastname: "titi", profils: ["anonymous"] }, + testprofil: "recruiter", + }, + { + alias: "unittestadminrecruiter", + passphrase: "adminrecruiterPass", + persons: { firstname: "toto", lastname: "titi", profils: ["anonymous"] }, + testprofil: "adminrecruiter", + }, + ], +}; + +// Apx +const apx = {}; +apx.data = {}; +apx.data.headers = {}; + +apx.generateKey = async (alias, passphrase) => { + try { + console.log(`\nGenerating keys for alias: ${alias}`); + const pgpParams = { + type: "ecc", + curve: "curve25519", + userIDs: [{ name: alias }], + passphrase: passphrase, + format: "armored", + }; + + const key = await openpgp.generateKey(pgpParams); + console.log(`Keys generated successfully for alias: ${alias}`); + + return { + alias, + passphrase, + privatekey: key.privateKey, + publickey: key.publicKey, + }; + } catch (error) { + console.error(`Error generating keys for alias: ${alias}`, error); + return {}; + } +}; + +apx.createIdentity = async (alias, passphrase) => { + try { + const { privatekey, publickey } = await apx.generateKey(alias, passphrase); + if (!privatekey || !publickey) { + throw new Error(`Failed to generate keys for ${alias}`); + } + console.log(`Identity created successfully for alias: ${alias}`); + return { alias, privatekey, publickey }; + } catch (error) { + console.error(`Error creating identity for alias: ${alias}`, error); + throw error; + } +}; + +apx.clearmsgSignature = async (privateKeyArmored, passphrase, message) => { + try { + const privateKey = await openpgp.readPrivateKey({ armoredKey: privateKeyArmored }); + let decryptedPrivateKey = privateKey; + + if (!privateKey.isDecrypted()) { + decryptedPrivateKey = await openpgp.decryptKey({ + privateKey, + passphrase + }); + } + + const signedMessage = await openpgp.sign({ + message: await openpgp.createMessage({ text: message }), + signingKeys: decryptedPrivateKey + }); + + return signedMessage; + } catch (error) { + console.error('Error signing message:', error); + return null; + } +}; + +apx.authenticate = async (alias, passphrase, privatekey) => { + try { + apx.data.headers.xalias = alias; + apx.data.headers.xdays = dayjs().valueOf(); + const msg = `${alias}_${apx.data.headers.xdays}`; + + console.log("pvk", privatekey); + apx.data.headers.xhash = await apx.clearmsgSignature(privatekey, passphrase, msg); + if (!apx.data.headers.xhash) { + throw new Error('Failed to generate xhash for authentication'); + } + + console.log(`Authentication successful for alias: ${alias}`); + return apx.data.headers; + } catch (error) { + console.error(`Error authenticating alias: ${alias}`, error); + throw error; + } +}; + + +ut.createIdentity = async (t) => { + try { + // Test if alias already exists + const getalias = await Pagans.getalias(t.alias); + if (getalias.status !== 404) { + console.log(`Alias ${t.alias} already exists. Deleting...`); + await Pagans.deletealias(t.alias); + console.log(`Deleted ${t.alias}.`); + } + + // Generate keys + const keys = await apx.createIdentity(t.alias, t.passphrase); + if (!keys.privatekey || !keys.publickey) { + throw new Error(`Failed to generate keys for ${t.alias}`); + } + + return keys; + } catch (error) { + throw new Error(`Error creating identity for ${t.alias}: ${error.message}`); + } +}; + +// Authentication process +ut.authenticate = async (t, privatekey, passphrase) => { + try { + const headers = await apx.authenticate(t.alias, passphrase, privatekey); + return headers; + } catch (error) { + throw new Error(`Error authenticating ${t.alias}: ${error.message}`); + } +}; + +ut.run = async () => { + console.log('Test Pagans Registration and Authentication'); + + for (const t of ut.test.pagans) { + try { + console.log(`Creating identity for ${t.alias}`); + const identity = await ut.createIdentity(t); + + console.log(`Authenticating ${t.alias}`); + const headers = await ut.authenticate(t, identity.privatekey, t.passphrase); + console.log(`Headers for ${t.alias}:`, headers); + + console.log(`All operations for ${t.alias} completed successfully.`); + } catch (error) { + console.error(`Error processing ${t.alias}: ${error.message}`); + } + } + + console.log('All test cases ran successfully'); +}; + +module.exports = ut; + + +if (require.main === module) { + ut.run().catch(err => { + console.error('Test case failed:', err); + }); +} diff --git a/apxtri/models/unittest/peterunittest.js b/apxtri/models/unittest/peterunittest.js new file mode 100644 index 0000000..2aff1d6 --- /dev/null +++ b/apxtri/models/unittest/peterunittest.js @@ -0,0 +1,75 @@ +/* +Unit testing +*/ +const assert = require("assert"); +const Checkjson = require("../Checkjson.js"); + +const ut = { name: "Checkjson" }; + +const schema = { + $schema: "http://json-schema.org/schema#", + title: "Dummy schema to test Checkjson.js", + description: "Checkjson is use on server as well as into a browser", + $comment: "We change schema type on the fly to simplify the test", + type: "object", + properties: { + totest: {}, + }, +}; + +const testproperties = [ + { + name: "test0", + data: { totest: true }, + properties: { totest: { type: "boolean" } }, + status: 200, + }, + { + name: "test1", + data: { totest: "blabla" }, + properties: { totest: { type: "string" } }, + status: 200, + }, + { + name: "test2", + data: { totest: 123 }, + properties: { totest: { type: "string" } }, + status: 417, + }, + { + name: "test3", + data: { totest: 123.13 }, + properties: { totest: { type: "integer" } }, + status: 200, // Should be 417 + }, + { + name: "test4", + data: { totest: "short" }, + properties: { totest: { type: "string", minLength: 10 } }, + status: 417, + }, +]; + +ut.testproperties = (options) => { + let msg = ""; + testproperties.forEach((t) => { + schema.properties = t.properties; + const res = Checkjson.schema.data(schema, t.data); + if (res.status != t.status) { + msg = msg == "" ? "Unconsistent testproperties() name list: " : `${msg},`; + if (options.verbose) { + console.log(t); + console.log(res); + } + msg += ` ${t.name} expected status ${t.status}, got ${res.status}`; + } + }); + return assert.deepEqual(msg, "", msg); +}; + +ut.run = (options) => { + console.log("Test Checkjson properties"); + ut.testproperties(options); +}; + +module.exports = ut; diff --git a/apxtri/routes/nations.js b/apxtri/routes/nations.js new file mode 100755 index 0000000..9827353 --- /dev/null +++ b/apxtri/routes/nations.js @@ -0,0 +1,35 @@ +const express = require( 'express' ); +const fs=require('fs-extra'); +const conf = require(`../../../adminapi/objects/tribes/itm/adminapi.json`); + +// Classes +const Nations = require( '../models/Nations.js' ); +// Middlewares +const checkHeaders = require( '../middlewares/checkHeaders' ); +const isAuthenticated = require( '../middlewares/isAuthenticated' ); +const router = express.Router(); + +/* +Manage nation +A major create a nation with at least a town => nation:{name, towns:[]} contracts/nationname.js + contracts/townsname.js +Manage a new towns in a nation => update nation:[nationname:towns:[]} contracts/townname.js +*/ + + +/** + * @api {put} adminapi/nations/viewtown/:town - nationlist from a town major + * @apigroup Nation + * @apiName nationlist + * @apiDescription get list of nation from a town to help this instance to update network topology + * @apiParam {string} town fromwhich the data come from + * @apiSuccess {object} refreshnetworktopoly + * * HTTP/1.1 200 OK + * {status:200,ref:"Nations",msg:"updated",data:{}}; + * + */ +router.put( '/', checkHeaders, isAuthenticated, ( req, res ) => { + const uptown = Nations.updatetown() + res.status(uptown.status).send(uptown) +} ) + +module.exports = router; diff --git a/apxtri/routes/notifications.js b/apxtri/routes/notifications.js new file mode 100644 index 0000000..a5ecfc6 --- /dev/null +++ b/apxtri/routes/notifications.js @@ -0,0 +1,245 @@ +const express = require("express"); +// Classes +const Notifications = require("../models/Notifications.js"); + +// Middlewares +const checkHeaders = require("../middlewares/checkHeaders"); +const isAuthenticated = require("../middlewares/isAuthenticated"); + +const router = express.Router(); + +/** + * wait Sagar feedback for language and label description + * @ api {post} /api/notifications/backend - Notification Backend post + * @apiName notifBackend + * @apiDescription Send an api result {status,ref,msg,data} to get personnalize notification by header.xlang abd by data + * @apiGroup Notification + * + * @apiBody {integer} status an http status + * @apiBody {string} ref an existing model name + * @apiBody {string} msg a key word existing in referentiual + * */ + +router.post("/backend", (req, res) => {}); + +/** + * @api {get} adminapi/notifications/messages/:alias/:tribeId -Get message list for alias in tribe + * @apiName notiflist + * @apiDescription Get list of notifications for an alias and a tribe + * @apiGroup Notifications + * + * @apiParam {string} alias + * @apiParam {string} tribeId + * @apiSuccess {object} notif content + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {status:200,ref:"Notification",msg:"Messagelist",data:{notif:[{tribeId,msg:{from(email or uuid or alias):[{dt,msg}]}}]} + * bouture + **/ +router.get("/messages/:alias/:tribeId", (req, res) => { + const getnot = Notification.get(req.params.alias, req.params.tribeId); + res.status(getalias.status).send(getalias); +}); + +/** + * @api {POST} adminapi/notifications/sendmail/:tribe/:template -Send personnalize emails + * @apiName Sendmail + * @apiDescription Send personnalize email with data from template store in ../../{tribe}/template/{template}.json and smtp in conf global or in /itm/{tribe}.json that must have valid parameter emailcontact must be authorized by the smtp + * "emailcontact": "noreply@smatchit.io", + * "smtp": { + * "host": "smtp-relay.brevo.com", + * "port": 587, + * "secure": false, + * "auth": { + * "user": "xx", + * "pass": "yy" + * } + * } + + * @apiGroup Notifications + * + * @apiParam {string} template + * @apiParam {string} tribe + * @apiBody {array} emails to send (array of valid email) + * @apiBody {object} data to personnalize template + * + * @apiSuccess {object} notif content + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {status:200,ref:"Notification",msg:"Messagelist",data:{notif:[{tribeId,msg:{from(email or uuid or alias):[{dt,msg}]}}]} + * bouture + */ +router.post( + "/sendmail/:tribe/:template", + checkHeaders, + isAuthenticated, + async (req, res) => { + const data = req.body.data; + data.emailsto = req.body.emails; + const pathtpl = `../../${req.params.tribe}/template/${req.params.template}_${req.session.header.xlang}.js`; + const sendemail = await Notifications.manageemail( + data, + pathtpl, + req.params.tribe + ); + res.status(sendemail.status).send(sendemail); + } +); + +/** + * @api {POST} adminapi/notifications/registeranonymous/:tribe/:mlist/:typekey/:data -Register email||phone to mlist + * @apiName register + * @apiGroup Notifications + * @apiDescription Register an email or phone into a mailinglist mlist + * @apiBody {string} tribe an existing tribe + * @apiBody {string} mlist a mailing list name + * @apiBody {string} key email or phone keyword + * @apiBod {string} srckey must exist in tribes/schema/lg/enumtrk_xx.json + * @apiParams {string} data the email or phone value + * @apiSuccess {object} update mailinglist/{mlist}.json successfull + * @apiSuccessExample {json} successfullmessage + * HTTP/1.1 200 OK + * {"status":200, "ref":"Notifications", "msg":"registersuccess", "data":{data, typekey, tribe, mlist, srckey, uuid}}} + * + */ +router.post("/registeranonymous", checkHeaders, (req, res) => { + //console.log("list registration ",req.body) + if (!req.body.typekey || !["email", "telephone"].includes(req.body.typekey)) { + return res.status(406).json({ + status: 406, + ref: "Notifications", + msg: "typekeyunknown", + data: { typekey: req.body.typekey }, + }); + } + const key = req.body.contactpoint + ? req.body.contactpoint + : req.body[req.body.typekey]; + result = Notifications.registertolist( + key, + req.body.typekey, + req.body.tribe, + req.body.mlist, + req.body.srckey, + req.session.header.xuuid + ); + + res.status(result.status).json(result); +}); +/** + * @api {GET} adminapi/notifications/unregister/:tribe/:mlist/:typekey/:data/:validation -Unregister email or phone from a mlist or all mlist + * @apiName unregister + * @apiGroup Notifications + * @apiDescription Register an email into a mailinglist mlist + * @apiParams {string} tribe an existing tribe + * @apiParams {string} mlist a mailing list name + * @apiParams {string} key email or phone + * @apiParams {string} srckey must exist in tribes/schema/lg/enumtrk_xx.json + * @apiParams {string} data the email or phone + * @apiParams {string} validation a key store in /tmp waiting to be approved, if "request" then send an email for confirmation, else if exist then remove email from list. + * @apiSuccess {object} update mailinglist/{mlist}.json successfull + * @apiSuccessExample {json} successfullmessage + * HTTP/1.1 200 OK + * {"status":200, "ref":"Notifications", "msg":"registersuccess", "data":{data, typekey, tribe, mlist, srckey, uuid}}} + * + */ + +router.get( + "/unregister/:tribe/:mlist/:typekey/:srckey/:data/:validation", + checkHeaders, + (req, res) => { + Notifications.registertolist = (typekey, tribe, mlist, srckey, uuid); + result = Notifications.registertolist( + req.params.typekey, + req.params.tribe, + req.params.mlist, + req.params.srckey, + req.session.header.xuuid + ); + res.status(result.status).json(result); + } +); + +/** + * @api {GET} adminapi/notifications/stat/maillinglst/:tribe --Statistic maillinglst + * @apiName statmaillinglst + * @apiGroup Notifications + * @apiDescription Mailling list statistique + * @apiParams {string} tribe an existing tribe + * + * @apiSuccess {object} with data results + * @apiSuccessExample {json} successfullmessage + * HTTP/1.1 200 OK + * { + * "status": 200, + * "ref": "Notifications", + * "msg": "statistics", + * "data": { + * "teasingwebpage": { + * "email_stayinformboth": 1, + * "email_stayinformseeker": 6 + * }, + * "gorillamkt": { + * "email_trouvemonjobrecruiter": 7, + * "email_trouvemonjobseeker": 142, + * "telephonefr_trouvemonjobrecruiter": 4, + * "telephonefr_trouvemonjobseeker": 103 + * }, + * "forumantony": { + * "email_trouvemonjobseeker": 18, + * "telephonefr_trouvemonjobseeker": 151 + * } + * } + *} + * + */ +router.get("/stat/maillinglst/:tribe", checkHeaders, async (req, res) => { + console.log("passe là"); + const resstat = Notifications.statmaillist(req.params.tribe); + res.status(resstat.status).json(resstat); +}); + +/** + * @api {POST} adminapi/notifications/contactanonymous/:tribe -Contact anonymous + * @apiName contactanonymous + * @apiGroup Notifications + * @apiDescription Register a contact in tribe and send a mail to admin of tribe + * @apiParams {string} tribe an existing tribe + * @apiBody {string} srckey: where it come from and eventualy email template name to use to send email , + * @apiBody {string} email to recontact + * @apiBody {string} others any other usefull key:value + * + * @apiSuccess {object} create/update tribe/contacts/{}.json successfull + * @apiSuccessExample {json} successfullmessage + * HTTP/1.1 200 OK + * {"status":200, "ref":"Contact", "msg":"success", "data":{"indexlist":[]}} + * + */ +router.post("/contactanonymous", checkHeaders, async (req, res) => { + const done = Actions[req.body.order] + ? await Actions[req.body.order](req.body, req.session.header) + : { status: 406, ref: "Actions", msg: "bodyerror", data: req.body }; + //console.log('routes contactanonymous ', req.body); + res.status(done.status).json(done); +}); +/** + * Same as /copntactanonymous but for authenticated user => data are updated in persons/itm/alias.json + */ +router.post( + "/contact/:tribe/:alias", + checkHeaders, + isAuthenticated, + (req, res) => { + const done = Actions[req.body.order] + ? Actions[req.body.order](req.body, req.session.header) + : { status: 406, ref: "Actions", msg: "bodyerror", data: req.body }; + console.log(req.body); + res.status(done.status).json(done); + } +); + +router.get("/contact", checkHeaders, isAuthenticated, (req, res) => { + res.status(200).json({ data: {} }); +}); + +module.exports = router; diff --git a/apxtri/routes/odmdb.js b/apxtri/routes/odmdb.js new file mode 100644 index 0000000..466b8dc --- /dev/null +++ b/apxtri/routes/odmdb.js @@ -0,0 +1,762 @@ +const express = require("express"); +const glob = require("glob"); +const fs = require("fs-extra"); +const path = require("path"); +const conf = require(`../../../adminapi/objects/tribes/itm/adminapi.json`); +const Odmdb = require("../models/Odmdb.js"); +// Middlewares +const checkHeaders = require("../middlewares/checkHeaders.js"); +const isAuthenticated = require("../middlewares/isAuthenticated.js"); +const router = express.Router(); + +/** + * @api {get} /adminapi/odmdb/schemas/:tribe - objects Get + * @apiGroup Odmdb + * @apiName getIndex + * @apiDescription Get objects available result is store in data.apx.conf for schema conf of adminapi schema (pagans,towns,... ) and data.apx.objectnames as array of schema name. Schema related to tribe are store in data.tribe.conf and data.tribe.objectnames where tribe come from header.xtribe + * @apiParams {string} tribe to get list of schema related to tribe + * @apiSuccess {object} contain data.indexname + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"objectslist", "data":{apx:{conf,objectnames:[]},tribe:{conf,objectnames:[]}}} + */ +router.get("/schemas/:tribe", checkHeaders, isAuthenticated, (req, res) => { + const data = { + tribename: req.params.tribe, + apx: { conf: {}, objectnames: [] }, + tribe: { conf: {}, objectnames: [] }, + }; + let trb; + glob.sync(`..{/,/../${req.params.tribe}/}schema/*.json`).forEach((f) => { + const objectname = path.basename(f, ".json"); + console.log(f); + trb = f.includes(req.params.tribe) ? "tribe" : "apx"; + if (objectname == "conf") { + data[trb].conf = fs.readJSONSync(f); + } else { + data[trb].objectnames.push(objectname); + } + }); + res.status(200).json({ status: 200, ref: "Odmdb", msg: "objectslist", data }); +}); +/** + * @api {get} /adminapi/odmdb/schema/:tribe/:objectname - Schema Get in the language header + * @apiGroup Odmdb + * @apiName getIndex + * @apiDescription Get schema in the requested language if login have accessright. object $ref or $id are replace by the relevant schema, option $ref are replace by enum list of authorised value + * + * @apiParams {string} tribe (adminapi,smatchit,..) to looking for + * @apiParams {string} objectname requested must exist in adminapi or tribe + * @apiSuccess {object} contain data.schema + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"schema", "data":{schema,objectname,lg} + */ +router.get( + "/schema/:tribe/:objectname", + checkHeaders, + isAuthenticated, + (req, res) => { + const objectPathname = `../../${req.params.tribe}/objects/${req.params.objectname}`; + console.log(objectPathname); + const retschema = Odmdb.Schema(objectPathname, true, req.header.xlang); + res.status(retschema.status).json(retschema); + } +); + +/** + * @api {get} /adminapi/odmdb/options/:tribe/objects/option/:optionname - Get option list in header language + * @apiGroup Odmdb + * @apiName getOption + * @apiDescription Get schema in the requested language if login have accessright. object $ref or $id are replace by the relevant schema, option $ref are replace by enum list of authorised value + * + * @apiParams {string} tribe (adminapi,smatchit,..) to looking for + * @apiParams {string} objectname requested must exist in adminapi or tribe + * @apiSuccess {object} contain data.schema + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"schema", "data":{schema,objectname,lg} + */ +router.get( + "/options/:tribe/objects/option/:optionname", + checkHeaders, + isAuthenticated, + (req, res) => { + const objectPathname = `../../${req.params.tribe}/objects/options/${req.params.optionname}_${req.header.xlang}.json`; + if (fs.existsSync(objectPathname)) { + res.status(200).json({ + status: 200, + ref: "Odmdb", + msg: "optionfind", + data: fs.readJsonSync(objectPathname), + }); + } else { + res.status(404).json({ + status: 404, + ref: "Odmdb", + msg: "optionnotfound", + data: { objectPathname }, + }); + } + } +); + +/** + * @api {get} adminapi/odmdb/idx/:tribe/:objectname/:indexname - index Get + * @apiGroup Odmdb + * @apiName getIndexbyindexname + * @apiDescription Get index file for an object + * + * @apiParams {string} tribe if common adminapi or tribename + * @apiParams {string} objectname If in conf.nationObjects then object is into nationchains/ else in tribes/xtribe/objectname/idx/indexname indexname + * @apiParams {String} indexname name of index file in /idx/indexnamme.json + * + * + * @apiError {json} objectNotfound the file does not exist + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + {"status":404,"ref":"Odmdb","msg":"pathnamedoesnotexist","data":{indexpath}} + * + * @apiSuccess {object} indexfile content + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"indexexist", "data":{indexname,content:{index file}} + */ +router.get( + "/idx/:tribe/:objectname/:indexname", + checkHeaders, + isAuthenticated, + (req, res) => { + console.log("passe"); + const indexpath = `../../${req.params.tribe}/objects/${req.params.objectname}/idx/${req.params.indexname}`; + console.log(indexpath); + if (fs.existsSync(indexpath)) { + res.status(200).json({ + ref: "Odmdb", + msg: "indexexist", + data: { + indexname: req.params.indexname, + content: fs.readJsonSync(indexpath), + }, + }); + } else { + res.status(404).json({ + ref: "Odmdb", + msg: "pathnamedoesnotexist", + data: { indexpath }, + }); + } + } +); + +/** + * @api {get} /adminapi/odmdb/rebuildidx/:tribe/:objectname - index refresh all + * @apiGroup Odmdb + * @apiName refreshAllIndex + * @apiDescription Rebuild all index for an object, this can be usefull in case crash or any data conflict. + * + * @apiParam {string} objectname Mandatory + * @apiParam {string} tribe adminapi or tribe name (smatchit), where object is store + * @apiSuccess {object} indexfile content + * @apiSuccessExample {json} successreindex + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"successreindex", "data":{"indexlist":[]}} + * + * @apiError {json} objectNotfound the file does not exist + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + {"status":404,"ref":"Odmdb","msg":"see nationchains/model/lg/Odmdb_xx.json","data":"object to render with msg"} + * + */ +router.get( + "/rebuildidx/:tribe/:objectname", + checkHeaders, + isAuthenticated, + (req, res) => { + console.log("reindex"); + // check validity and accessright + + const objectPathname = `../../${req.params.tribe}/objects/${req.params.objectname}`; + if (!fs.existsSync(objectPathname)) { + res.status(404).json({ + status: 404, + ref: "Odmdb", + msg: "pathnamedoesnotexist", + data: { indexpath: objectPathname }, + }); + return false; + } + if ( + conf.api.nationObjects.includes(req.params.objectname) && + !req.session.header.xprofils.includes("mayor") + ) { + res.status(403).json({ + status: 403, + ref: "Odmdb", + msg: "profilnotallow", + data: { profils: "mayor" }, + }); + return false; + } + if ( + !conf.api.nationObjects.includes(req.params.objectname) && + !req.session.header.xprofils.includes("druid") + ) { + res.status(403).json({ + status: 403, + ref: "Odmdb", + msg: "profilnotallow", + data: { profils: "druid" }, + }); + return false; + } + const reindex = Odmdb.idxfromitm(objectPathname, "I", {}, {}, [], {}); + res.status(reindex.status).json(reindex); + } +); + +/** + * @api {post} /adminapi/odmdb/itm/:tribe/:objectname - item Create + * @apiGroup Odmdb + * @apiName postItm + * @apiPermission none + * @apiDescription Add an new item (data) into a collection of objectname items. Before Check data integrity with the relevant schema. + * Then create a new primarykey. For multilanguage return see nationchains/model/lg/Odmdb_xx.json. + * @apiParam {string} tribe adminapi or tribe name (smatchit), where object is store + * @apiParam {string} objectname Place where to create new item, schema and version are available in /objectname/conf.json + * + * @apiBody {Object} data must pass Checkjson.js with schema + * + * @apiSuccess {json} data idxprimary Value of idxprimary into objectname collection + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"cudsuccessfull", "data":{"itm":{}}} + * + * @apiError {json} schemanotfound The objectname schema is not found + * @apiError {json} pathnamedoesnotexist The objectname does not exist for the tribe + * @apiError {json} missingprimarykey Body data must have primarykey to be created + * @apiError {json} unconsistencyapxidx some Body data get unique key that already exist + * @apiError {json} checkjsonfalse The body data are not consistent with the schema + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + * {"status":404,"ref":"Odmdb","msg":"see nationchains/model/lg/Odmdb_xx.json","data":"object to render with msg"} + * + */ +router.post( + "/itm/:tribe/:objectname", + checkHeaders, + isAuthenticated, + (req, res) => { + // Create an item of an object with no specificities + // if specificities then create a route / model that import odmdb + const objectPathname = `../../${req.params.tribe}/objects/${req.params.objectname}`; + const postitm = Odmdb.cud(objectPathname, "C", req.body, { + xprofils: req.session.header.xprofils, + xalias: req.session.header.xalias, + }); + res.status(postitm.status).json(postitm); + } +); + +/** + * @api {put} /adminapi/odmdb/itm/:tribe/:objectname - item Update + * @apiGroup Odmdb + * @apiName putItm + * @apiPermission none + * @apiDescription Update an item (data) into a collection of objectname items. Before Check data integrity with the relevant schema. + * Then create a new primarykey. For multilanguage return see nationchains/model/lg/Odmdb_xx.json. + * @apiParam {string} tribe adminapi or tribe name (smatchit), where object is store + * @apiParam {string} objectname Place where to create new item, schema and version are available in /objectname/conf.json + * + * @apiBody {Object} data must pass Checkjson.js with schema + * + * @apiSuccess {json} data idxprimary Value of idxprimary into objectname collection + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"cudsuccessfull", "data":{"itm":{}}} + * + * @apiError {json} schemanotfound The objectname schema is not found + * @apiError {json} pathnamedoesnotexist The objectname does not exist for the tribe + * @apiError {json} missingprimarykey Body data must have primarykey to be created + * @apiError {json} unconsistencyapxidx some Body data get unique key that already exist + * @apiError {json} checkjsonfalse The body data are not consistent with the schema + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + * {"status":404,"ref":"Odmdb","msg":"see nationchains/model/lg/Odmdb_xx.json","data":"object to render with msg"} + * + */ +router.put( + "/itm/:tribe/:objectname", + checkHeaders, + isAuthenticated, + (req, res) => { + // Create an item of an object with no specificities + // if specificities then create a route / model that import odmdb + const objectPathname = `../../${req.params.tribe}/objects/${req.params.objectname}`; + const postitm = Odmdb.cud(objectPathname, "U", req.body, { + xprofils: req.session.header.xprofils, + xalias: req.session.header.xalias, + }); + res.status(postitm.status).json(postitm); + } +); + +/** + * @api {delete} /adminapi/odmdb/itm/:tribe/:objectname/:apxid/:primaryid - item Delete + * @apiGroup Odmdb + * @apiName deleteItm + * @apiPermission none + * @apiDescription Delete an item (data) into a collection of objectname items. This will reindex all idx for this object, but this won't check if this item.apxid is not already use somewhere else. If you use this endpoint be sure that no one will use it, if not then a get request will answer not found. For data integrity is better to use a scpecifc endpoint per tribe to manage a bunch of objects. + * @apiParam {string} tribe adminapi or tribe name (smatchit), where object is store + * @apiParam {string} objectname Place where to create new item, schema and version are available in /objectname/conf.json + * @apiParam {string} apxid the key that is use as unique id for this object you find it in the schema.apxid + * @apiBody {Object} data must pass Checkjson.js with schema + * + * @apiSuccess {json} data idxprimary Value of idxprimary into objectname collection + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"cudsuccessfull", "data":{"itm":{}}} + * + * @apiError {json} schemanotfound The objectname schema is not found + * @apiError {json} pathnamedoesnotexist The objectname does not exist for the tribe + * @apiError {json} missingprimarykey Body data must have primarykey to be created + * @apiError {json} unconsistencyapxidx some Body data get unique key that already exist + * @apiError {json} checkjsonfalse The body data are not consistent with the schema + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + * {"status":404,"ref":"Odmdb","msg":"see nationchains/model/lg/Odmdb_xx.json","data":"object to render with msg"} + * + */ +router.delete( + "/itm/:tribe/:objectname/:apxid/:primaryid", + checkHeaders, + isAuthenticated, + (req, res) => { + // Create an item of an object with no specificities + // if specificities then create a route / model that import odmdb + const objectPathname = `../../${req.params.tribe}/objects/${req.params.objectname}`; + const itmtoremove={} + itmtoremove[req.params.apxid]=req.params.primaryid; + const delitm = Odmdb.cud(objectPathname, "D", itmtoremove, { + xprofils: req.session.header.xprofils, + xalias: req.session.header.xalias, + }); + res.status(delitm.status).json(delitm); + } +); + +/** + * @api {post} /adminapi/odmdb/searchitms/:tribe/:objectname - items Search + * @apiGroup Odmdb + * @apiName searchItms + * @apiPermission none + * @apiDescription Search dynamicaly in an object collection of items, results can be a list of apxid or an object {apxid1:{propertie:value,..}}. To get object you must specify in body the key fields. See usage example. TODO: This will evolve with deeper search technics + * @apiParam {string} tribe name (smatchit), where object is store + * @apiParam {string} objectname object name where looking for + * @apiBody {array} [apxid] list of apxid prefilter when for perfomance you want filter the search investigation. If omit then it is looking for in any item object + * @apiBody {array} [fields] string "all" or list of properties of object you want to get (profils user must have accessright in Read for those fields, a value 'unauthorized' can be return in this case) + * @apiBody {string} [condition] an array of condition {propertieA:[value1,value2],propertieB:[valu9],function:["name1",name2],...} select objectname id that match proprieteA = valu1 or value2 AND proprieteB=valu9 AND function name1(object) return true AND function name2(object) function are string code into schema @TODO ... + * + * @apiSuccess {json} contain {status,ref,msg,data} + * @apiSuccessExample {json} Return objects per id + * HTTP/1.1 200 OK from body {apxid:[itmid],fields:[field1,field2]} + * {"status":200, "ref":"Odmdb", "msg":"searchresult", "data":{"itms":{itmid:{field1,field2}]}} + * @apiSuccessExample {json} Return arrays of ids + * HTTP/1.1 200 OK from {question:[{"color":['blue','red']},{size:["<100"]},{function:name}]} + * {"status":200, "ref":"Odmdb", "msg":"searchresult", "data":[itm1,itm2]} + * @apiError {json} objectdoesnotexist the obbject does not exist for the tribe + * @apiError {json} unconsistentcondition condition format is not relevant + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + * {"status":404,"ref":"Odmdb","msg":"templatestring Odmdb_xx.json","data":"object to render with msg"} + * + */ +router.post( + "/searchitms/:tribe/:objectname", + checkHeaders, + isAuthenticated, + (req, res) => { + const objectPathname = `../../${req.params.tribe}/objects/${req.params.objectname}`; + const ressearch = Odmdb.search(objectPathname, req.body, { + xprofils: req.session.header.xprofils, + xalias: req.session.header.xalias, + }); + res.status(ressearch.status).json(ressearch); + } +); + +/** + * @api {get} /adminapi/odmdb/itm/:tribe/:objectname/:primaryindex - item Get + * @apiGroup Odmdb + * @apiName getItemFromId + * @apiDescription Get itm for a primaryid of an object + * @apiParam {string} tribe adminapi or tribe name (smatchit), where object is store + * @apiParam {String} objectname name Mandatory if in conf.nationObjects then file is into nationchains/ else in /tribes/xtribe/objectname + * @apiParam {String} primaryindex the unique id where item is store + * + * @apiError {json} objectfiledoesnotexist the file item does not exist + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + * {status:404,ref: "Odmdb",msg: "objectfiledoesnotexist",data: { objectpath }} + * @apiSuccess {object} indexfile content + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {status:200,ref:"Odmdb",msg:"itmfound", data:{itm:{} }} * + * + */ +// indexname = objectname_key_value.json +router.get( + "/itm/:tribe/:objectname/:primaryindex", + checkHeaders, + isAuthenticated, + (req, res) => { + const objectpath = `../../${req.params.tribe}/objects/${req.params.objectname}/itm/${req.params.primaryindex}.json`; + + if (fs.existsSync(objectpath)) { + const readobj = Odmdb.r( + `../../${req.params.tribe}/objects/${req.params.objectname}`, + req.params.primaryindex, + { + xprofils: req.session.header.xprofils, + xalias: req.session.header.xalias, + } + ); + res.status(readobj.status).json(readobj); + /*res.status(200).json({ + status: 200, + ref: "Odmdb", + msg: "itmfound", + data: fs.readJsonSync(objectpath), + });*/ + } else { + res.status(404).json({ + status: 404, + ref: "Odmdb", + msg: "objectfiledoesnotexist", + data: { objectpath }, + }); + } + } +); +/** + * @api {get} https://anypaxtridns/adminapi/Checkjson.js - schema Checkjson.js + * @apiGroup Odmdb + * @apiName checkjsonjs + * @apiDescription Public js lib to import in a browser by :
+ * `````` + * to import in a node.js:
+ * ```const Checkjson = require(`Checkjson.js`);``` + * + * with functions:
+ * Checkjson.schema.validation(schema) that return
+ * - {status:200, ref:"Checkjson", msg:"validcheck"} => all rules are correct
+ * - {status:406, multimsg:[{ref:"Checkjson",msg:"errorkey",data:{}}]}
+ * + * Checkjson.schema.data(schema{json},data{json},withschemacheck{boolean}) that return
+ * - {status:200, ref:"Checkjson", msg:"validcheck"} => all data keys respect schema rules
+ * - {status:417, multimsg:[{ref:"Checkjson",msg:"errorkey",data:{}}]}
+ * + * To identify issues, get the language errorkey list with a get + * + * To check a property from an existing format + * + * Checkjson.testformat=(str, format)=>{ + * return null if format does not exist in Checkjson.schema.properties.format + * return true if str respect the format (false in other case) + */ + +/** + * @api {get} https://wall-ants.ndda.fr/adminapi/schema/:objectname - schema Get public + * @apiGroup Odmdb + * @apiName getPublicSchema + * @apiDescription Get a Schema model from public apxtri (nations, pagans,persons,towns, tribes,wwws) + * @apiSuccess {json} contain json file + * @apiSuccessExample {json} Fichier direct + * HTTP/1.1 200 Success-response: + { + "$id": "https://wall-ants.ndda.fr/schema/pagan", + "$comment": "To create account bin apxtri", + "title": "Pagans identity", + "description": "A numeric id in the nationchains world", + "type": "object", + "properties": { + "publickey": { + "title": "Alias's publickey", + "description": "Public key generate with openpgp.js", + "type": "string", + "format": "pgppublickey" + }, + "alias": { + "title": "Alias", + "description": "text to remember easily a public key", + "type": "string", + "minLength": 4, + "pattern": "^[a-z0-9]*$" + }, + "dt_delete": { + "title": "Date of death", + "description": "Date of alias delete request, your will will be apply", + "type": "string", + "format": "date-time" + }, + "will": { + "title": "Will script after death", + "description": "This will script will be apply on your data 30 days after your death", + "type": "string" + } + }, + "required": ["publickey", "alias"], + "apxid": "alias", + "apxuniquekey": ["publickey"], + "apxidx": [ + { "name": "lst_alias", "keyval": "alias" }, + { "name": "alias", "keyval": "alias" } + ], + "apxaccessrights": { + "owner": { "R": [], "D": [] }, + "anonymous": { "C": [], "R": ["alias"] }, + "pagan": { "R": ["alias", "publickey"] } + } +} + + * @apiError {json} contain json file + * @apiErrorExample {string} nginx html not found message + * HTTP/1.1 404 Not Found + * ... +**/ + +/** + * @api {get} https://tribedns/:tribe/schema/:objectname.json - schema Get from tribe + * @apiGroup Odmdb + * @apiName getPrivateSchema + * @apiDescription Get a tribe schema or schema/lg/:objectname_xx.json this is served by nginx not express. tribedns is the domain name (ex:smatchit.io) + * + * @apiParam {string} tribe where schema is stored ex;smatchit + * @apiParam {String} objectname the json file name ex persons.json or for language /lg/persons_fr.json + * + * @apiError {object} ref objectname note found + * @apiErrorExample {json} Error-response: + * HTTP/1.1 404 Not Found + * ... + * @apiSuccess {json} data contains schema requested + * @apiSuccessExample {json} Success-Response for : https://smatchit.io/smatchit/schema/persons.json + * HTTP/1.1 200 Success-response: + * {{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "/smatchit/schema/sirets", + "title": "Siret is a legal french company", + "description": "A recruiter can active a jobad if a maxnumber is not reach for this siret. Maxnumber is set depending of an offer or can be set manualy", + "type": "object", + "properties": { + "siret": { + "title": "siret", + "description": "A unique string identifying a company ", + "type": "string", + "minLength": 14, + "pattern": "^[0-9]*$" + }, + "owner": { + "title": "Owner of this siret", + "description": "For accessright purpose this is set by the alias that pay the first time a subscription", + "type": "string" + }, + "dt_create": { + "type": "string", + "format": "date-time", + "default": "dayjs.now()" + }, + "dt_update": { + "type": "string", + "format": "date-time" + }, + "subscription": { + "title": "Offer subscribe", + "type": "array", + "items": { + "type": "object", + "properties": { + "offer": { "type": "string", "enum": ["A", "B", "C", "FREE"] }, + "dt_payment": { "type": "string", "format": "date-time" } + } + } + }, + "emailbilling":{ + "type":"string", + "format":"email" + }, + "namebilling":{ + "type":"string" + }, + "maxactivejobad": { + "title": "Number of active jobad at the same time", + "description": "Alloaw by subscription payment for a date inside the last dt_payment and offer", + "type": "integer" + }, + "activejobad": { + "title": "Current number of active jobadd", + "type": "integer" + }, + "frenchlocation": { + "title": "Location", + "description": "use franch gov refential to locaize", + "$ref": "nationchains/schema/frenchlocation" + }, + "denomination": { + "title": "Company name", + "type": "string" + } + }, + "required": ["siret"], + "additionalProperties": true, + "apxid": "siret", + "apxuniquekey": ["siret"], + "apxidx": [ + { + "name": "lst_siret", + "keyval": "siret" + } + ], + "apxaccessrights": { + "owner": { + "D": [], + "R": [ + "siret", + "dt_create", + "dt_update", + "subscription", + "maxactivejobadd", + "activejobadd", + "frenchlocation", + "demomination" + ], + "U": ["frenchlocation", "demomination"] + }, + "druid": { + "C": [], + "D": [], + "R": [ + "siret", + "dt_create", + "dt_update", + "subscription", + "maxactivejobadd", + "activejobadd", + "frenchlocation", + "demomination" + ], + "U": [ + "subscription", + "maxactivejobadd", + "activejobadd", + "frenchlocation", + "demomination" + ] + }, + "pagans": { "C": [] }, + "adminrecruiter": { + "C": [], + "R": [ + "siret", + "dt_create", + "dt_update", + "subscription", + "maxactivejobadd", + "activejobadd", + "frenchlocation", + "demomination" + ], + "U": ["frenchlocation", "demomination"] + }, + "recruiter": { + "R": [ + "siret", + "dt_create", + "dt_update", + "subscription", + "maxactivejobadd", + "activejobadd", + "frenchlocation", + "demomination" + ] + } + } +}} + */ + +/** + * @api {put} https://wall-ants.ndda.fr/odmdb/schema/:tribe/:objectname - schema Put + * @apiGroup Odmdb + * @apiName putSchema + * @apiDescription Replace a schema by another one need druid profil for a tribe + * + * @apiParam {String} objectname + * + * @apiBody {string} schemapath where to store schema .../schema + * @apiBody {string} objectpath where to store object ...objectname/idx/conf.json + * @apiBody {json} schema content + * @apiBody {json} schemalang content in lg + * @apiBody {string} lang define which schemalg is (2 letters) + * + * @apiError {object} ref objectmodel to get in the right language + * @apiErrorExample {json} Error-response: + * HTTP/1.1 404 Not Found + * {"status":404,"ref":"Odmdb","msg":"schemanotfound","data":{"fullpath"}} + * + * @apiSuccess {object} data contains schema requested + * HTTP/1.1 200 Success-response: + * {"status":200,"data":{schema}} + * + * + */ +router.put( + "schema/:tribe/:objectname", + checkHeaders, + isAuthenticated, + (req, res) => { + const fullpath = path.resolve( + `${__dirname}/tribes/${req.session.header.xworkon}/schema/${req.params.pathobjectname}.json` + ); + const set = Odmdb.setObject( + path.resolve(`${__dirname}/tribes/${req.session.header.xworkon}`) + ); + + if (fs.existsSync(fullpath)) { + res.status(200).json({ data: fs.readJsonSync(fullpath) }); + } else { + res + .status(404) + .json({ msg: "schemanotfound", ref: "odmdb", data: { fullpath } }); + } + } +); + +/** + * @api {get} https://wall-ants.ndda.fr/adminapi/objects/tplstring/:modelname_lg.json - translation notif Get public + * @apiGroup Odmdb + * @apiName getPublicModelmessagekey + * @apiDescription Get a public json object for the ref: modelname in language lg, to get a template description with key msg + * @apiParam {string} modelname Mandatory + * @apiSuccess {json} contain json file + * @apiSuccessExample {json} Fichier direct + * HTTP/1.1 200 Success-response: + * { + "alreadyexist": "Un object {{objectname}} avec la clé {{key}} existe déjà avec {{val}}", + "doesnotexist": "L'object {{objectname}} avec la clé {{key}} ,'existe pas avec {{val}}", + "getschema": "Schema {{{conf.name}}}", + "schemanotfound": "Schema introuvable dans {{{schemaPath}}}", + "pathnamedoesnotexist": "Le repertoire n'existe pas {{{indexpath}}}", + "objectfiledoesnotexist": "Le fichier n'existe pas {{{objectpath}}}", + "cudsuccessfull": "Mise à jour effectuée avec succés", + "missingprimarykey": "Il manque une clé primaire apxid pour stocker et identifier les objects", + "unconsistencyapxidx": "L'index {{name}} doit contenir en objkey au moins {{apxid}} car keyval n'est pas unique", + "profilnotallow": "Vous n'avez pas le profil de {{profils}}, cette action n'est pas authorisée", + "successreindex": "Objet reindexé à partir des items, vos index sont à jour", + "indexexist":"L'indexe existe" + * } + * @apiError {json} contain json file + * @apiErrorExample {string} nginx html not found message + * HTTP/1.1 404 Not Found + * ... +**/ + +module.exports = router; diff --git a/apxtri/routes/pagans.js b/apxtri/routes/pagans.js new file mode 100755 index 0000000..4421eed --- /dev/null +++ b/apxtri/routes/pagans.js @@ -0,0 +1,422 @@ +const express = require("express"); +const fs = require("fs-extra"); +const dayjs = require("dayjs"); +const path = require("path"); +// Classes +const Pagans = require("../models/Pagans.js"); +const Odmdb = require("../models/Odmdb.js"); +// Middlewares +const checkHeaders = require("../middlewares/checkHeaders.js"); +const isAuthenticated = require("../middlewares/isAuthenticated.js"); + +const conf = require(`../../../adminapi/objects/tribes/itm/adminapi.json`); +const currentmod = "pagans"; +const log = conf.api.activelog.includes(currentmod); + +const router = express.Router(); + +/** + * Alias exist then return public key or not + * @api {get} adminapi/pagans/alias/:alias - alias Get + * @apiName isalias + * @apiGroup Pagans + * @apiDescription If alias exist return its publickey + * + * @param {string} alias + * + * @apiError {json} aliasdoesnotexist + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + {"status":404,"ref":"pagans","msg":"aliasdoesnotexist","data": { alias}} + * + * @apiSuccess {object} indexfile content + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, ref:"pagans","msg":"aliasexist","data": { alias, publicKey }} + * * + **/ +router.get("/alias/:alias", (req, res) => { + const getalias = Pagans.getalias(req.params.alias); + res.status(getalias.status).send(getalias); +}); +/** + * @api {get} adminapi/pagans/logout - pagan Logout + * @apiName Removetoken + * @apiGroup Pagans + * @apiDescription Remove server's token only the owner of the token (no one else can delete a token ) + * + * @apiSuccess {object} indexfile content + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {status: 200, ref: "Pagans", msg: "logout" + * + */ +router.get("/logout", checkHeaders, isAuthenticated, (req, res) => { + if (log) console.log(currentmod, "Logout:", req.session.header); + const logout = Pagans.logout( + req.session.header.xalias, + req.session.header.xtribe, + req.session.header.xdays, + req.session.header.xhash + ); + res.status(logout.status).json(logout); +}); +/** + * @api {get} adminapi/pagans/isauth - pagan isAuthenticated? + * @apiName isAuth + * @apiGroup Pagans + * @apiDescription Check if pagan's token is still valid + * + * @apiError (400) missingheaders + * @apiError (400) xaliasdoesnotexist + * @apiError (400) signaturefailled + * @apiError (401) aliasanonymous + * @apiError (404) tribedoesnotexist + * + * @apiSuccess (200) valid + * {object} data contains indexfile requested + * + */ +router.get("/isauth", checkHeaders, isAuthenticated, (req, res) => { + res.status(200).send({ + status: 200, + ref: "headers", + msg: "authenticated", + data: { + xalias: req.session.header.xalias, + xprofils: req.session.header.xprofils, + }, + }); +}); + +/** + * @api {post} adminapi/pagans - pagan Post + * @apiName addpagan + * @apiGroup Pagans + * @apiDescription + * Create a pagan account from alias, publickey, if trusted recovery => + * If trustedtribe is true then create a person in xtribe/person/xalias.json with profil.auth={email,privatekey, passphrase}. + * + * Middleware isAuthenticated check that: + * - xhash is well signed from private key linked to the publickey of alias + * - check that alias does not already exist (if yes then verifiedsigne would be false) + * Need to wait next block chain to be sure that alias is register in the blokchain + * @apiBody {string} alias available (that does not already exist check get /api/alias/:alias that must return 404). + * @apiBody {string} publickey + * @apiBody {string} [email] if specified then an email is sent to it with public and privatekey + * @apiBody {string} [privatekey] + * @apiBody {string} [passphrase] if not specidied => passphrase="" + * @apiBody {string} [trustedtribe] the tribename if not specified then the process will only create a pagan identity, else an item person is create for trustedtribe (that must exist with profil 'person'). To create a person with an existing pagan identity use put /api/person/:alias after authenticated you (headers). In case a person is created then we use all valid other apiBody respecting the persons schema (see put persons) + * + * @apiError {json} objectNotfound the file does not exist + * @apiErrorExample {json} + * HTTP/1.1 404 Not Found + {"status":404,"ref":"Odmdb","msg":"pathnamedoesnotexist","data":{indexpath}} + * + * @apiSuccess {object} indexfile content + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Odmdb", "msg":"indexexist", "data":{indexname,content:{index file}} + * + */ +router.post("/", checkHeaders, isAuthenticated, async (req, res) => { + if (log) console.log(currentmod, "post with", req.body); + const role = { + xalias: req.session.header.xalias, + xprofils: req.session.header.xprofils, + }; + const emailregex = + /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; + if ( + !( + req.body.trustedtribe && + req.body.email && + emailregex.test(req.body.email) + ) + ) { + res.status(400).json({ + status: 400, + ref: "Pagans", + msg: "emailerr", + data: { email: req.body.email }, + }); + return; + } + const objpagan = { alias: req.body.alias, publickey: req.body.publickey }; + console.log(path.resolve(`../objects/pagans`)); + const newpagan = Odmdb.cud(`../objects/pagans`, "C", objpagan, role); + const createprocess = { + status: 200, + ref: "Pagans", + msg: "successfulcreate", + data: { alias: req.body.alias }, + }; + if (newpagan.status == 200) { + if (req.body.email) { + const emailsent = await Pagans.sendmailkey({ + alias: req.body.alias, + privatekey: req.body.privatekey, + tribe: req.session.header.xtribe, + passprhase: req.body.passphrase, + publickey: req.body.publickey, + email: req.body.email, + lg: req.session.header.xlang, + }); + createprocess.data.emailsent = emailsent.status == 200; + createprocess.data.email = req.body.email; + createprocess.data.tribe = req.session.header.xtribe; + if (emailsent.status != 200) { + console.log("pagans err to send email emailsent: ", emailsent); + createprocess.data.emailerror = emailsent.data.err; + } + } + if (req.body.trustedtribe) { + const persondata = { + alias: req.body.alias, + owner: req.body.alias, + profils: ["anonymous", "pagans", "persons"], + recoveryauth: { + email: req.body.email, + privatekey: req.body.privatekey, + publickey: req.body.publickey, + passphrase: req.body.passphrase, + }, + }; + const personup = Odmdb.cud( + `../../${req.body.trustedtribe}/objects/persons`, + "C", + persondata, + { xprofils: ["anonymous", "pagans"], xalias: req.body.alias } + ); + if (log) console.log(currentmod, "person create", personup); + if (personup.status == 200) { + createprocess.data.createperson = true; + } else { + createprocess.data.createperson = false; + createprocess.data.errorperson = true; + createprocess.data.errpersonup = personup.data; + if (log) + console.log( + currentmod, + "Warning pagan created but person not created and no recovery registration", + personup + ); + } + res.status(createprocess.status).json(createprocess); + } else { + res.status(newpagan.status).json(newpagan); + } + } else { + //error to create pagan certaily already exist + res.status(newpagan.status).json(newpagan); + } +}); +/** + * @api {delete} adminapi/pagans/alias/:alias - pagan Delete + * @apiName deletepagan + * @apiGroup Pagans + * @apiDescription + * Delete an alias and his publickey, this mean that publickey disapear as well as alias. We set dt_delete + * */ +router.delete("/alias/:alias", checkHeaders, isAuthenticated, (req, res) => { + const personpath = `../objects/pagans`; + const role = { + xalias: req.session.header.xalias, + xprofils: req.session.header.xprofils, + }; + req.session.header.role; + const delperson = Odmdb.cud( + personpath, + "U", + { alias: req.params.alias, dt_delete: dayjs().toISOString() }, + role, + true + ); + if (log) + console.log( + currentmod, + `DELETE person ${personpath}/${req.params.alias}.json ` + ); + if (log) console.log(delperson); + res.status(delperson.status).json(delperson); + + if (log) + console.log( + `DELETE pagans /api/adminapi/objects/pagans/${req.params.alias}.json` + ); + const result = Pagans.delete(req.params.alias, req.session.header); + res.status(result.status).send(result); +}); +/** + * @api {delete} adminapi/pagans/person/:tribe/:alias - person Delete + * @apiName deleteperson + * @apiGroup Pagans + * @apiDescription + * Unsubscribe a person to a tribe => remove a person item and all data link to this alias. An asynchrone process turn each day to clean data in tribe, if a persons does not exist anymore in the tribe. Pagans alias is still existing as it is autonomous. It is possible to delete pagans see "pagan Delete". + * @apiHeader {array} xprofils list of profil of authenticated user + * @apiHeader {string} xalias current user + * @apiParam {string} tribe where person alias exist + * @apiParam {string} alias to delete as person + * */ +router.delete( + "/person/:tribe/:alias", + checkHeaders, + isAuthenticated, + (req, res) => { + const personpath = `../../${req.params.tribe}/objects/persons`; + const role = { + xalias: req.session.header.xalias, + xprofils: req.session.header.xprofils, + }; + req.session.header.role; + const delperson = Odmdb.cud( + personpath, + "D", + { alias: req.params.alias }, + role, + true + ); + if (log) + console.log( + currentmod, + `DELETE person ${personpath}/${req.params.alias}.json ` + ); + if (log) console.log(currentmod, "delete person ", delperson); + res.status(delperson.status).json(delperson); + } +); + +/** + * @api {get} adminapi/pagans/person/:alias - person Get + * @apiName getpersondata + * @apiDescription Get person information from his alias for a xtribe (data and profils per apps) + * @apiGroup Pagans + * + * @apiParam {string} alias + * + * @apiSuccess (200) personExist + * @apiSuccessExample {json} + * {status:200, ref:"pagans",msg:"personexist",data: { person } } + * + * @apiError (404) Notfound + * @apiErrorExample {json} + * {status: 404, ref:"pagans",msg:"persondoesnotexist",data: { person } } + * + * @todo check accessright for req.session.header.xalias to see if jhe can get person data + * if req.param.alias == req.session.header.xalias => Owner + * else need accessright to on person set at R + * */ +router.get("/person/:alias", checkHeaders, isAuthenticated, (req, res) => { + console.log( + path.resolve(`../../${req.session.header.xtribe}/objects/persons`) + ); + const getperson = Odmdb.r( + `../../${req.session.header.xtribe}/objects/persons`, + req.params.alias, + { xprofils: req.session.header.xprofils, xalias: req.session.header.xalias } + ); + res.status(getperson.status).send(getperson); +}); + +/** + * @api {put} adminapi/pagans/person/:tribe - person Put + * @apiName updateperson + * @apiGroup Pagans + * @apiDescription add a person = alias in tribe. xalias must be authenticated. This end point have to be use the first time a person is create then use item Update PUT /api/adminapi/odmdb/itm/:tribe/persons.
This endpoint is the only way to change profils of a person by itself (authenitcated alias = person.alias) and can be done only with req.body.addprofils req.body.removeprofils. + * @apiHeader {string} xhash authenthicate hash with current user keys + * @apiHeader {string} xalias current user + * @apiHeader {string} xprofils profil list + * @apiParam {string} tribe an existing tribe + * @apiBody {object} schema:persons https://dnstribe/tribe/schema/persons.json + * @apiBody {string} [addprofils] must be alone no other Body field + * @apiBody {string} [removeprofils] must be alone + */ +router.put("/person/:tribe", checkHeaders, isAuthenticated, (req, res) => { + //console.log(req.body); + const pathobj = `../../${req.params.tribe}/objects/persons`; + const action = fs.existsSync(`${pathobj}/itm/${req.body.alias}.json`) + ? "U" + : "C"; + //set req.body to be in line with schema + if ( + action == "U" && + ((req.body.addprofils && + ["seekers", "recruiters", "adminrecruiters"].includes( + req.body.addprofils + )) || + (req.body.removeprofils && + ["seekers", "recruiters", "adminrecruiters"].includes( + req.body.removeprofils + ))) + ) { + const person = fs.readJsonSync(`${pathobj}/itm/${req.body.alias}.json`); + if (!person.profils.includes(req.body.addprofils)) { + if (req.body.addprofils) { + person.profils.push(req.body.addprofils); + } + if ( + req.body.removeprofils && + person.profils.includes(req.body.removeprofils) + ) { + person.profils = person.profils.filter( + (e) => e !== req.body.removeprofils + ); + Odmdb.cud( + `../../${req.params.tribe}/objects/${req.body.removeprofils}`, + "D", + { alias: req.body.alias }, + { + xprofils: req.session.header.xprofils, + xalias: req.session.header.xalias, + } + ); + } + } + person.dt_update = dayjs().toISOString(); + fs.outputJSONSync(`${pathobj}/itm/${req.body.alias}.json`, person); + //console.log(person) + res.status(200).json({ + status: 200, + ref: "Pagans", + msg: "profilupdate", + data: { alias: person.alias, profils: person.profils }, + }); + } + if (!req.body.addprofils && !req.body.removeprofils) { + if (!req.body.profils) { + req.body.profils = ["anonymous", "pagans", "persons"]; + } + const personup = Odmdb.cud(pathobj, action, req.body, { + xprofils: req.session.header.xprofils, + xalias: req.session.header.xalias, + }); + if (log) console.log(currentmod, " personupdate or create:", personup); + res.status(personup.status).json(personup); + } +}); + +/** + * @api {post} /adminapi/pagans/keyrecovery - recovery keys + * @apiName recoveryKey + * @apiGroup Pagans + * @apiDescription Send mails with all registers identities (one per alias where recoveryauth.email is register). Search can be request by email or by alias for a tribe. It is looking for in person.recoveryauth.email to send keys. One mail is sent by alias. So if n alias has the same recoveryaut.email then it will send n email. + * @apiBody {string} emailalias type of search (email or alias) + * @apiBody {string} tribe tribename into looking for + * @apiBody {string} search a text containing email or an alias to looking for + * + * @apiSuccess {object} send recovery email + * @apiSuccessExample {json} Success-Response: + * HTTP/1.1 200 OK + * {"status":200, "ref":"Pagans", "msg":"recoveryemailsent", "data":{email,tribe,numberemailsent'}} + * + * @apiError (404) {string} recoveryemailnotfound email does not exist for this tribe + * @apiErrorExample {json} + * {status: 404, ref:"pagans",msg:"recoveryemailnotfound",data: { tribe,email } } + * + */ +router.post("/keyrecovery", checkHeaders, (req, res) => { + const recores=Pagans.keyrecovery(req.body.emailalias,req.body.tribe,req.body.search,req.session.header.xlang) + res.status(recores.status).json(recores); +}); + +module.exports = router; diff --git a/apxtri/routes/towns.js b/apxtri/routes/towns.js new file mode 100755 index 0000000..c76ff8e --- /dev/null +++ b/apxtri/routes/towns.js @@ -0,0 +1,32 @@ +const express = require("express"); +const path = require("path"); + +// Classes +const Towns = require("../models/Towns.js"); +const Notifications = require("../models/Notifications.js"); +// Middlewares +const checkHeaders = require("../middlewares/checkHeaders.js"); +const isAuthenticated = require("../middlewares/isAuthenticated.js"); +const router = express.Router(); + +/** + * @api {get} /towns/ownershipr/:alias - town owner change + * @apiName changeowner + * @apiGroup Towns + * @apiDescription Change owner (major role) of a town (server) after a first install or just to resale it. Only the current major can run this. + * @param {string} alias an alias that will become owner of a town + * @apiSuccess (object) ownerchangesuccess + * @apiSuccessExample {json} + * HTTP/1.1 200 OK + * {status:200, ref:"towns",msg:"ownerchangesuccess",data: { alias } } + * @apiError {object} aliasnotallow + * @apiErrorExample {json} + * HTTP/1.1 403 Forbidden + * {status:403,ref:"towns",msg:"aliasnotallow",data: { alias} } + * + **/ +router.get("/changeowner/:alias",checkHeaders, isAuthenticated, (req, res) => { + res.send(Towns.changeowner(req.params.alias, req.session.header.xalias)); +}); + +module.exports = router; diff --git a/apxtri/routes/trackings.js b/apxtri/routes/trackings.js new file mode 100644 index 0000000..7f5d1b0 --- /dev/null +++ b/apxtri/routes/trackings.js @@ -0,0 +1,74 @@ +const express = require("express"); +const glob = require("glob"); +const fs = require("fs-extra"); +const path = require("path"); +const conf = require(`../../../adminapi/objects/tribes/itm/adminapi.json`); +const Odmdb = require("../models/Odmdb.js"); +// Middlewares +const checkHeaders = require("../middlewares/checkHeaders"); +const isAuthenticated = require("../middlewares/isAuthenticated"); +const router = express.Router(); + + +/** + * @api {get} https://dns.xx/trk/pathtofile? - tracking system + * @apiGroup Trackings + * @apiName trackingsystem + * @apiDescription + * + * **WARNING** a cors issue must be fix, currently this tracking work for the same domain. + * + * without header:
+ *
https://dns.xx/trk/pathtofile?alias=anonymous&uuid=1b506f71-1bff-416c-9057-cb8b86296f60&srckey=btnregister&version=1&lg=fr
+ *
+ * with header+ *
https://dns.xx/trk/pathtofile?srckey=btnregister&version=1
+ *
+ * where pathtofile is a ressource accessible from https://dns.xx/pathtofile
+ * For dummy pathtofile for apxtri project, you have:+ * /cdn/log/1x1.png (a 1pixel image 95 bytes ) + * /cdn/log/empty.json (an empty jason 2 bytes) + * + * html usage to track a loading page or email when a picture is load + * using apxwebapp in /src/ we got: + *
< img src="static/img/photo.jpg" data-trksrckey="loadpage" data-version="1" >
+ *
+ * in js action:
+ *
+ *
+ *
+ * To hit an eventlistener+ *
axios.get("https://dns.xx/trk/cdn/empty.json?alias=anonymous&uuid=1b506f71-1bff-416c-9057-cb8b86296f60&srckey=btnregister&version=1");
+ *
+ * If no js available (example:email or pdf document)+ *
< img src="https://dns.xx/trk/static/img/photo.jpg?alias=anonymous&uuid=1b506f71-1bff-416c-9057-cb8b86296f60&srckey=loadpage&version=1"
+ *
+ *
+ *
+ * This will hit a tracker then redirect to url> *
+ *
+ * **if you use apx.js** : in html add in < button >, < img >, < a > tag data-trksrc="srckey"
+ *
+ * < img src="https://dns.xx/static/img/photo.jpg" data-trkversion="1" data-trksrckey="registerform">
+ * < button data-trksrc="https://dns.xx/static/img/photo.jpg" data-trkversion="1" data-trksrckey="registerform">
+ *
+ * A lazyloader can also be track.
+ * < img lazysrc="trk/static/img/photo.jpg data-trksrckey="loadpage" data-version="1" >
+
+ *
+ * Tracking log are store into tribe/logs/nginx/tribe_appname.trk.log
+ * Src have to be manage in tribe/api/models/lg/src_en.json
+ * {"srckey":{"app":"presentation|app|apptest","title":"","description":""}}
+ *
+ * @apiParam {String} alias=anonymous if authenticated we get from headers
+ * @apiParam {String} uuid a uuid v4 generate the first time a web page is open on a browser
+ * @apiParam {String} srckey source action that trig this get
+ * @apiParam {integer} version=1 can be an int, date or any version of the src
+ * @apiParam {integer} [tm] a timestamp of action when it is not immediate (for offline app)
+ *
+ */
+
+
+
+
+module.exports=router;
\ No newline at end of file
diff --git a/apxtri/routes/tribes.js b/apxtri/routes/tribes.js
new file mode 100755
index 0000000..162781c
--- /dev/null
+++ b/apxtri/routes/tribes.js
@@ -0,0 +1,448 @@
+const express = require( 'express' );
+const fs = require( 'fs-extra' );
+const path = require( 'path' );
+const glob = require('glob');
+const conf = require(`../../../adminapi/objects/tribes/itm/adminapi.json`);
+
+// Classes
+const Tribes = require( '../models/Tribes.js' );
+// Middlewares
+const checkHeaders = require( '../middlewares/checkHeaders' );
+const isAuthenticated = require( '../middlewares/isAuthenticated' );
+const router = express.Router();
+
+
+/**
+* @api {get} adminapi/tribes/conf/:tribe - tribe list
+* @apiName getconf
+* @apiDescription Get list of route and model for a town server
+* @apiGroup Tribes
+*
+* @apiSuccess (object) get tribes conf on this server
+* @apiSuccessExample {json}
+* HTTP/1.1 200 OK
+* {status:200,ref:"Tribes",msg:"tribesconf",data:{routes:[],modele:[{model:,tplstrings:[lg,lg]}]}}
+*/
+router.get('/config/:tribe', checkHeaders,isAuthenticated,(req,res)=>{
+ /*console.log("passe la")
+ AJOUTER gestion accessright
+ req.session.header.accessrights.data[ req.params.tribe ] &&
+ req.session.header.accessrights.data[ req.params.tribe ].tribeid &&
+ req.session.header.accessrights.data[ req.params.tribe ].tribeid.includes( 'R' )
+ */
+ if("authorize"=="authorize"){
+ const tribconf=`../../adminapi/objects/tribes/itm/${req.params.tribe}.json`
+ if (!fs.existsSync(tribconf)){
+ res.status(404).json({status:404,ref:"Tribes",msg:"tribedoesnotexist", data:{tribe:req.params.tribe}})
+ }else{
+ res.status(200).json({satatus:200,ref:"Tribes",msg:"tribconf",data:{conf:fs.readJsonSync(tribconf)}})
+ }
+ }else{
+ res.status( 403 )
+ .json( { msg: [ 'forbidenAccess' ], ref: 'Tribes' } )
+ .end();
+ }
+})
+
+/**
+* @api {get} adminapi/tribes/www/:tribeId - tribe list
+* @apiName getlisttrib
+* @apiDescription Get list of www object (space web)
+* @apiGroup Tribes
+*
+* @apiParam {String} tribeId it identify an existing tribe*
+* @apiSuccess (object) listwww contains folder name in www for tribeId
+* @apiSuccessExample {json} listwww
+* HTTP/1.1 200 OK
+* {status:200,ref:"Tribes",msg:"listwww",data:{listwww}}
+*/
+router.get('/www', checkHeaders,isAuthenticated,(req,res)=>{
+ let listwww=[]
+ glob.sync(`${conf.dirtown}/tribes/${req.params.tribeId}/www/*`).forEach(d=>{
+ listwww.push(d.split("/").pop())
+ })
+ res.status(200).json({status:200,ref:"Tribes",msg:"listwww",data:{listwww}})
+})
+
+//router.post('www/') to create a webspace
+
+//router.put('www/:app') to update
+
+//router.delete('www/:tribeId/:app)
+
+router.post('/actionanonyme',checkHeaders,(req,res)=>{
+ if (!fs.existsSync(`${conf.dirtown}/tribes/${req.session.header.xtribe}/actions/${req.body.action}.js`)){
+ res.status(403).send({status:403,msg:"actionmissing",ref:"Tribes", data:{action:req.body.action,tribe:req.session.header.xtribe}})
+ }
+ const action = require(`${conf.dirtown}/tribes/${req.session.header.xtribe}/actions/${req.body.action}.js`)
+ const resaction= action.run(req.body,req.session.header);
+ res.status(resaction.status).send(resaction);
+})
+
+router.post('/action',checkHeaders,isAuthenticated,(req,res)=>{
+
+})
+
+
+router.get( '/clientconf/:tribeid', checkHeaders, isAuthenticated, ( req, res ) => {
+ /*
+ get a clientconf.json for a tribeid depending of user accessright
+ if tribeid == all and user is admin of apxtri => get /tmp/clientconfglob.json
+ req.session.header.accessrights, req.session.header.apixpaganid
+ */
+ console.log( `Tribes/clientconf for tribeid:${req.params.tribeid}` )
+ if( req.params.tribeid == "all" && req.session.header.accessrights.data.apxtri && req.session.header.accessrights.data.apxtri.tribeid && req.session.header.accessrights.data.apxtri.tribeid.includes( 'R' ) ) {
+ res.status( 200 )
+ .send( { moreinfo: fs.readJsonSync( `${config.tmp}/clientconfglob.json`, 'utf-8' ) } );
+ return;
+ }
+ if( req.session.header.accessrights.data[ req.params.tribeid ] &&
+ req.session.header.accessrights.data[ req.params.tribeid ].tribeid &&
+ req.session.header.accessrights.data[ req.params.tribeid ].tribeid.includes( 'R' ) &&
+ fs.existsSync( `${config.tribes}/${req.params.tribeid}/clientconf.json` ) ) {
+ // const conftribeid = { moreinfo: {} }
+ // conftribeid.moreinfo[ req.params.tribeid ] = fs.readJsonSync( `${config.tribes}/${req.params.tribeid}/clientconf.json`, 'utf-8' );
+ res.status( 200 )
+ .send( { moreinfo: [ fs.readJsonSync( `${config.tribes}/${req.params.tribeid}/clientconf.json`, 'utf-8' ) ] } );
+ return;
+ }
+ // if not authorized or dos not exist return empty
+ // no specific message is send for security reason (check only log)
+ res.status( 403 )
+ .send( { info: [ 'forbidenAccess' ], models: 'Tribes' } )
+ .end();
+} )
+router.put( '/', checkHeaders, isAuthenticated, ( req, res ) => {
+ console.log( 'Create a new tribeid, with a useradmin' )
+ console.log( ' send data = clientconf.json with all parameter.' )
+ // !!!!! check for security any ; \n or so because data can be used into shell
+ const add = Tribes.create( req.body );
+ res.status( add.status )
+ .send( add.payload )
+} )
+router.delete( '/archivetribeid/:tribeid', checkHeaders, isAuthenticated, ( req, res ) => {
+ console.log( "request archive tribeid" )
+ const archive = Tribes.archive( req.params.tribeid );
+ res.status( archive.status )
+ .send( archive.payload )
+} );
+router.post( '/spaceweb', checkHeaders, isAuthenticated, ( req, res ) => {
+ // !!!!! check for security any ; \n or so because data can be used into shell
+ console.log( 'Create a new webapp for xworkon ' )
+ req.body.tribeid = req.session.header.xworkon;
+ const add = Tribes.addspaceweb( req.body )
+ res.status( add.status )
+ .send( add.payload )
+} )
+router.get( '/spaceweb/components/:tribeid/:website/:key', checkHeaders, ( req, res ) => {
+ // check if key is valid before continue
+ // exemple: get Tribes/spaceweb/components/ndda/mesa/123?rep=appmesatable/appsimpletable.mustache
+ const file = `${config.tribes}/${req.params.tribeid}/spacedev/${req.params.website}/src/ctatic/components/${req.query.path}`
+ console.log( `Request components file from ${file}` )
+ if( fs.existsSync( file ) ) {
+ res.sendFile( file );
+ } else {
+ res.send( `console.error("Missing components file in ${req.params.tribeid}/spacedev/${req.params.website}/src/ctatic/components/${req.query.path}");` );
+ }
+} )
+router.get( '/plugins/:tribeid/:pluginname/:key/:filename', ( req, res ) => {
+ // No accessright possible cause it is load on the fly
+ // @todo Check key to authorize access to the plugin (key comme from user ACCESSRIGHTS[tribeid plugin owner:pluginname]).key
+ // return a file into /:tribeid owner of plugin/plugins/:pluginname/components/:filename
+ // if not exist or invalid key then return console.error
+ const file = `${config.tribes}/${req.params.tribeid}/plugins/${req.params.pluginname}/components/${req.params.filename}`
+ console.log( 'Tribes/plugins/ ', file )
+ if( fs.existsSync( file ) ) {
+ res.sendFile( file );
+ } else {
+ res.send( `console.error("Missing plugin file in ${req.params.tribeid}/plugins/${req.params.pluginname}/components/${req.params.filename}");` );
+ }
+} );
+
+router.get( '/dirls', checkHeaders, isAuthenticated, ( req, res ) => {
+ // url adminapi/tribes/dirls?rep=referentials/dataManagement
+ // request information about a req.query.rep from header xworkon/
+ // return
+ // {file:[{}],dir:[{}]}
+ // @todo check if isAuthorized and exist
+
+ console.log( 'request dirls', `${config.tribes}/${req.session.header.xworkon}/${req.query.rep}` );
+ if( !fs.existsSync( `${config.tribes}/${req.session.header.xworkon}/${req.query.rep}` ) ) {
+ res.status( 404 )
+ .send( { 'info': [ 'dirnotexist' ], model: 'Tribes' } );
+ }
+ const info = Tribes.dirls( req.session.header.xworkon, req.query.rep );
+ console.log( info )
+ res.status( info.status )
+ .send( info.payload );
+} )
+router.delete( '/ls', checkHeaders, isAuthenticated, ( req, res ) => {
+ // check Accessright with D or O on each
+ // url adminapi/tribes/ls
+ // req.body.files=[listfiles file to delete ]
+ const authfiles = Tribes.checkaccessfiles( req.body, 'D', req.session.header.accessrights, req.session.header.apixpaganid );
+ authfiles.ok.forEach( f => { fs.remove( `${config.tribes}/${f}` ); } )
+ res.status( 200 )
+ .send( { 'info': [ 'fileauthdeleted' ], models: 'Tribes', moreinfo: authfiles } )
+} );
+router.put( '/sendjson', checkHeaders, isAuthenticated, ( req, res ) => {
+ //req.body = {object:spacedev, path:website/src/data/tpldataname_lg.json, data:{...}}
+ //console.log( req.body )
+ const dest = `${config.tribes}/${req.session.header.xworkon}/${req.body.object}/${req.body.path}`;
+ console.log( `Send json to saved to ${dest}` );
+ if( !( req.body.object && fs.existsSync( `${config.tribes}/${req.session.header.xworkon}/${req.body.object}` ) ) ) {
+ res.status( '404' )
+ .send( { info: [ 'objectmissiong' ], models: 'Tribes', moreinfo: `object: ${req.body.object} does not exist req.body must {object, data, path} into data ${req.session.header.xworkon}/${req.body.object}` } )
+ } else {
+ if( fs.existsSync( `${config.tribes}/${req.session.header.xworkon}/${req.body.object}/${req.body.path}` ) ) {
+ // exist so can be update check accessright update on this
+ //A REVOIR hasAccessrighton( req.body.object, "U" );
+ } else {
+ // AREVOIRhasAccessrighton( req.body.object, "C" );
+ }
+ fs.outputJsonSync( dest, req.body.data );
+ res.status( 200 )
+ .send( { info: [ 'filesaved' ], models: 'Tribes' } )
+ }
+} );
+router.post( '/downloadls', checkHeaders, isAuthenticated, ( req, res ) => {
+ // midlleware hasAccessrighton.js is not apply here only to access/update/create information inside an object
+ // to get file a user need accessrights to data: object: R or to Own it
+ // or if exist a .info.json into folder get shared as R in uuid
+
+ //req.body contain list of path file or folder if only 1 file then download it, otherwise zip list and send zip file
+
+ const authfiles = Tribes.checkaccessfiles( req.body.files, 'R', req.session.header.accessrights, req.session.header.xpaganid );
+ if( authfiles.ok.length == 1 ) {
+ // bidouille en attendnat de faire un .zip binaire propre
+ if( !authfiles.ok[ 0 ].includes( '.xml' ) ) {
+ res.status( 200 )
+ .download( `${config.tribes}/${authfiles.ok[0]}`, authfiles.ok[ 0 ] );
+ } else {
+ fs.copySync( `${config.tribes}/${authfiles.ok[0]}`, `${config.tribes}/${config.mayorId}/www/app/webapp/static/tmp/${authfiles.ok[ 0 ]}` )
+ }
+ } else if( authfiles.ok.length > 1 ) {
+ // on zip et on envoie
+ //res.status( 200 )
+ // .download( `${config.tribes}/${authfiles.ok[0]}`, authfiles.ok[ 0 ])
+ res.status( 200 )
+ .attachment( `${config.tribes}/${authfiles.ok[0]}` );
+
+ } else {
+ req.body.filepon
+ res.status( 403 )
+ .send( 'Forbidden access' )
+ }
+} );
+
+
+router.post( '/upfilepond', checkHeaders, isAuthenticated, ( req, res ) => {
+ console.log( 'post adminapi/tribes/uploadfilepond' );
+ // Store file and return a unique id to save button
+ // that provide folder where to store it
+ const formidable = require( 'formidable' );
+ const form = formidable( { multiples: false } );
+ form.parse( req, ( err, fields, files ) => {
+ if( err ) { next( err ); return; }
+ //console.log( 'fields',fields);
+ // fileMetadaObject send
+ let context = JSON.parse( fields.filepond );
+ let idfile = files.filepond.path;
+ let name = files.filepond.name;
+ let subfolder = context.subfolder;
+ name = name.replace( /[ ,'"’]/g, "_" );
+ //console.log( 'files.filepond:', files.filepond );
+ console.log( idfile, `${config.tribes}/${req.session.header.xworkon}/www/${subfolder}/${name}` )
+ // On le supprime s'il existe deja
+ fs.removeSync( `${config.tribes}/${req.session.header.xworkon}/www/${subfolder}/${name}` );
+ // mv tmp
+ fs.moveSync( idfile, `${config.tribes}/${req.session.header.xworkon}/www/${subfolder}/${name}` );
+ //res.status(200).send({models:"Tribes",info:["Savedsuccess"],moreinfo:{id:file.filepond.path}})
+ //return for filepond
+ res.writeHead( 200, { 'Content-Type': 'text/plain' } );
+ res.end( idfile );
+ } )
+} );
+router.delete( '/file', checkHeaders, isAuthenticated, ( req, res ) => {
+ //src = objectfolder with accessright/...
+ //hasAccessrighton( "www", "D" ),
+ if( !req.query.src ) {
+ res.status( 404 )
+ .send( { info: [ 'deleteerror' ], models: "Tribes", moreinfo: "your del req need a src" } )
+ return;
+ };
+ // A REVOIR hasAccessrighton( req.query.src.split( '/' )[ 0 ], "D" );
+ console.log( 'Remove file', `${config.tribes}/${req.session.header.xworkon}/${req.query.src}` )
+ console.log( req.body )
+ fs.removeSync( `${config.tribes}/${req.session.header.xworkon}/${req.query.src}` );
+ res.status( 200 )
+ .send( { info: [ 'Successfullremove' ], models: "Tribes" } )
+} );
+router.post( '/uploadfile', checkHeaders, isAuthenticated, ( req, res ) => {
+ console.log( 'upload a file ' )
+ /* Authentification is needed to get a TOKEN
+ curl -X POST -H "xtribe: apxtri" -H "xworkon: pvmsaveurs" -H "xlang: fr" -H "xpaganid: 1" -H "xauth: 1" -H "xapp: pvmsaveurs:pvmsaveurs" -H "Content-Type: application/json" -d '{"LOGIN":"adminapxtri","PASSWORD":"Trze3aze!"}' http://pvmsaveurs.pvmsaveurs.fr/app/users/login
+ if exist replace xpaganidTOKEN with payload.TOKEN value
+
+ curl -H "xtribe: pvmsaveurs" -H "xworkon: pvmsaveurs" -H "xlang: fr" -H "xpaganid: adminapxtri" -H "xauth: xpressuuisToken" -H "xapp: pvmsaveurs:pvmsaveurs" -F 'data=@filename.xx' http://pvmsaveurs.pvmsaveurs.fr/app/Tribes/uploadfile
+ */
+ const formidable = require( 'formidable' );
+ const form = formidable( { multiples: false } );
+ form.parse( req, function ( err, fields, files ) {
+ //console.log( files.data )
+ var oldPath = files.data.path;
+ var newPath = `${config.tribes}/${req.session.header.xworkon}/${clientconf.uploadzip[files.data.name].dest}`;
+ console.log( 'oldPath', oldPath )
+ console.log( 'newPath', newPath )
+ var rawData = fs.readFileSync( oldPath )
+ fs.outputFile( newPath, rawData, function ( err ) {
+ if( err ) {
+ console.log( err );
+ return res.status( 405 )
+ .send( { info: [ 'savederror' ], models: "Tribes", moreinfo: "your file was not able to be saved into the server" } )
+ } else {
+ return res.status( 200 )
+ .send( {
+ info: [ "successfullsent" ],
+ models: "Tribes"
+ } );
+ }
+ } )
+ } );
+} );
+router.post( '/uploadzip', checkHeaders, ( req, res ) => {
+ console.log( 'uploadzip a file ' )
+
+ /* no authentification to upload a zip filename into adminapi/tribes/${xworkon}/${clientconf.uploadzip[filename].dest}
+ unzip it using the password ${clientconf.uploadzip[filename].psw
+ if no error then run the callback ${clientconf.uploadzip[filename].callback
+ but a password to unzip
+ in clientconf.json need to be set
+ "uploadzip": {
+ "articlesTribespvm.zip": {
+ "comment": "unzip with overwrite if same name",
+ "psw": "azPI1209qtrse",
+ "dest": "importexport/tmp",
+ "unzipoption": "-aoa",
+ "callback": "importexport/integrationitem.js"
+ }
+ },
+ Example:
+ cd where zip file is stored
+ curl -H "xtribe: pvmsaveurs" -H "xworkon: pvmsaveurs" -H "xlang: fr" -H "xpaganid: adminapxtri" -H "xauth: 1" -H "xapp: pvmsaveurs:pvmsaveurs" -F 'data=@articlesTribespvm.zip' http://pvmsaveurs.pvmsaveurs.fr/app/Tribes/uploadzip
+
+ */
+ const clientconf = fs.readJSONSync( `${config.tribes}/${req.session.header.xworkon}/clientconf.json` )
+ if( !clientconf.uploadzip ) {
+ return res.status( '404' )
+ .send( { info: [ "missconf" ], models: "Tribes", moreinfo: `no uploadzip in clientconf for ${req.session.header.xworkon} please contact apxtri admin ` } );
+ };
+ const uploadzip = clientconf.uploadzip;
+ const formidable = require( 'formidable' );
+ const form = formidable( { multiples: false } );
+ form.parse( req, function ( err, fields, files ) {
+ //console.log( files.data )
+ var oldPath = files.data.path;
+ if( !Object.keys( clientconf.uploadzip )
+ .includes( files.data.name ) ) {
+ return res.status( 403 )
+ .send( { info: [ "notAllowed" ], models: "Tribes", moreinfo: `file ${files.data.name} not allowed to be upload` } )
+ } else {
+ console.log( "context:", clientconf.uploadzip[ files.data.name ] )
+ var newPath = `${config.tribes}/${req.session.header.xworkon}/${clientconf.uploadzip[files.data.name].dest}`;
+ //console.log( 'oldPath', oldPath )
+ //console.log( 'newPath', `${newPath}/${files.data.name}` )
+ fs.moveSync( oldPath, `${newPath}/${files.data.name}`, { overwrite: true } );
+ const cp = require( 'child_process' );
+ //console.log( `7z e -p${clientconf.uploadzip[ files.data.name ].psw} ${newPath}/${files.data.name}` );
+ console.log( '7z', [ 'e', `-p${clientconf.uploadzip[ files.data.name ].psw}`, `${newPath}/${files.data.name}`, `-o${config.tribes}/${req.session.header.xworkon}/${clientconf.uploadzip[ files.data.name ].dest}`, clientconf.uploadzip[ files.data.name ].unzipoption ] );
+ var newFiles = cp.spawnSync( '7z', [ 'e', `-p${clientconf.uploadzip[ files.data.name ].psw}`, `${newPath}/${files.data.name}`, `-o${config.tribes}/${req.session.header.xworkon}/${clientconf.uploadzip[ files.data.name ].dest}`, clientconf.uploadzip[ files.data.name ].unzipoption ] );
+ console.log( newFiles.output.toString() )
+ if( newFiles.output.toString()
+ .includes( 'Everything is Ok' ) ) {
+ if( clientconf.uploadzip[ files.data.name ].callback ) {
+ const integ = require( `${config.tribes}/${req.session.header.xworkon}/${clientconf.uploadzip[files.data.name].callback}` )
+ .run();
+ console.log( 'integration', integ )
+ return res.status( integ.status )
+ .send( integ.payload );
+ } else {
+ return res.status( 200 )
+ .send( {
+ info: [ "successfullsent" ],
+ models: "Tribes"
+ } );
+ }
+ } else {
+ return res.status( 400 )
+ .send( {
+ info: [ "zipfileerror" ],
+ models: "Tribes",
+ moreinfo: newFiles.output.toString()
+ } )
+ }
+ }
+ } )
+} );
+
+router.post( '/upload', checkHeaders, isAuthenticated, ( req, res ) => {
+ 1 // ACHANGER VIA usage sendjson
+ // url adminapi/tribes/upload?save=tmp&rep=referentials/dataManagement
+ // if save=tmp then store in a tmp file
+ // if save=ok then mv the tmp file to the folder
+ // midlleware hasAccessrighton.js is not apply here only to access/update/create information inside an object
+ // to upload a file a user need accessrights to data: object: C or to Own it
+ // or if dir.file exist a .info.json into folder get shared as C in uuid accessright
+ /*
+ to add in front
+
+ */
+ console.log( 'Envoie image' )
+ console.log( 'body', req.body );
+ console.log( 'params', req.params );
+ //const authfolder = Tribes.checkaccessfiles( req.params.rep, 'C', req.session.header.accessrights, req.session.header.xpaganid );
+ // cheack autorisation to create or replace a file for this accessrights user
+ const authfolder = { ok: "tt" }
+ if( authfolder.ok ) {
+ if( req.params.save == 'file' ) {
+ if( fs.existsSync( req.body.filepond ) ) {
+ fs.mv( req.body.filepond, req.params.rep );
+ }
+ };
+ // voir si c'est toujours pertinent car upload est géré par filepond pour les image
+ if( req.params.save == 'upload' ) {
+ const form = formidable( { multiples: false } );
+ form.parse( req, ( err, fields, files ) => {
+ if( err ) { next( err ); return; }
+ let thefile = files.filebond.path;
+ fs.outputFileSync()
+ console.log( 'thefile:' + thefile );
+ res.writeHead( 200, { 'Content-Type': 'text/plain' } );
+ res.end( theFile );
+ } )
+ }
+ } else {
+ res.status( 403 )
+ .send( 'forbiden access' );
+ }
+} );
+/*
+Manage tribeid into /data/tribee/tribeid
+client space dedicated
+
+@Todo
+clientconfglob copy cut from Referentials.clientconfglob
+clientconf.json copy cut from Referentials.clientconf
+list of tribeid copy cut from Referentials.
+Add a tribeid
+update clientconf
+
+
+*/
+
+
+
+module.exports = router;
diff --git a/apxtri/routes/wwws.js b/apxtri/routes/wwws.js
new file mode 100644
index 0000000..1526e22
--- /dev/null
+++ b/apxtri/routes/wwws.js
@@ -0,0 +1,156 @@
+const express = require("express");
+const path = require("path");
+
+// Classes
+const Wwws = require("../models/Wwws.js");
+// Middlewares
+const checkHeaders = require("../middlewares/checkHeaders");
+const isAuthenticated = require("../middlewares/isAuthenticated");
+
+const router = express.Router();
+// GET api/wwws/conf/:tribeId/:website
+// if profils accessright return the nginx conf in ${conf.dirtown}/tribes/${req.param.tribeId}/www/nginx_${req.params.tribeId}_${req.params.website}.conf
+router.get(
+ "/conf/:tribeId/:website",
+ checkHeaders,
+ isAuthenticated,
+ (req, res) => {
+ res.send(Www.configlist(req.params.tribeId));
+ }
+);
+router.post(
+ "/conf/:tribeId/:website",
+ checkHeaders,
+ isAuthenticated,
+ (req, res) => {
+ res.send(Wwws.create(req.params.tribeId));
+ }
+);
+
+/**
+ * @api {put} /adminapi/wwws/webcomponents - Get local web components
+ * @apiGroup Wwws
+ * @apiName getwco
+ * @apiDescription Get web component from backend to localstorage for development. This is anonymous but must be authenticated with accessright to other tribe to get their web component.
For production it will generate a unique id that store to add in updatelocaldb with in production space /js/uniqueid.js css/uniqueid.css pagename.html with link in it
+ *
+ * @apiBody {object} tribelistwco { wco:{tribe:[wconame]}, mode:"dev"|"prod"}
+*/
+router.put(
+ "/updatelocalwcoanonymous",
+ checkHeaders,
+ (req, res) => {
+ console.log("localstorage anonymous for web component", req.session.header.xalias);
+ req.session.header.xprofils = ["anonymous"];
+ console.log(req.session.header.xprofils);
+ //ajouter une detection de changement
+ const getlocal = Wwws.initlocalwco(
+ req.body,
+ req.session.header.xprofils,
+ req.session.header.xlang
+ );
+ res.status(getlocal.status).json(getlocal);
+ }
+);
+
+/**
+ * @api {get} /adminapi/wwws/updatelocaldbanonymous/:tribe/:appname/:pagename/:version - Get localdb for app anonymous only
+ * @apiGroup Wwws
+ * @apiName getappcontextforanonymous
+ * @apiDescription Get data base from backend to localstorage for anonymous (see Get app data model)
+ *
+ * @apiParams {string} tribe (adminapi,smatchit,..) to looking for
+ * @apiParams {string} appname agregate a full data referential to store localy
+ * @apiParams {string} pagename app page name
+ * @apiParams {interger} version the current version
+*/
+router.get(
+ "/updatelocaldbanonymous/:tribe/:appname/:pagename/:version",
+ checkHeaders,
+ (req, res) => {
+ console.log("pass localstorage anonymous", req.session.header.xalias);
+ req.session.header.xprofils = ["anonymous"];
+ console.log(req.session.header.xprofils);
+ //ajouter une detection de changement
+ const getlocal = Wwws.initlocaldata(
+ req.params.tribe,
+ req.params.appname,
+ req.params.pagename,
+ req.params.version,
+ req.session.header.xprofils,
+ req.session.header.xlang
+ );
+ res.status(getlocal.status).json(getlocal);
+ }
+);
+
+/**
+ * @api {get} /adminapi/wwws/updatelocaldb/:tribe/:appname/:pagename/:version - Get localdb for app
+ * @apiGroup Wwws
+ * @apiName getappcontext
+ * @apiDescription Get data base from backend to localstorage for authenticated user
+ *
+ * @apiParams {string} tribe (adminapi,smatchit,..) to looking for
+ * @apiParams {string} appname agregate a full data referential to store localy
+ * @apiParams {string} pagename app page name
+ * @apiParams {interger} version the current version
+ * @apiSuccess {object} contain new version data model for a local web app in a PWA logical in the language of the header or if no new version exist then return
+ * @apiSuccessExample {json} datamodelupdate
+ * {"status":200, "ref":"Wwws", "msg":"datamodelupdate", "data":{version,confpage,profils,schema,options,ref,tpl,tpldata}}
+ * @apiSuccessExample {json} datamodelnoupdate
+ * HTTP/1.1 200 OK
+ * {"status":200, "ref":"Wwws", "msg":"datamodelupdate", "data":{version,confpage,profils,schema,options,ref,tpl,tpldata}}
+ * @apiSuccessExample {json} pagedoesnotexist
+ * {status: 200,ref: "Wwws", msg: "pagedoesnotexist", data: { pagename } }
+ * @apiSuccessExample {json} forbidenaccess
+ * {status: 200,ref: "Wwws", msg: "forbidenaccess",data: { pagename, profils } }
+ */
+router.get(
+ "/updatelocaldb/:tribe/:appname/:pagename/:version",
+ checkHeaders, isAuthenticated,
+ (req, res) => {
+ console.log("pass localstorage", req.session.header.xalias);
+ console.log(req.session.header.xprofils);
+ //ajouter une detection de changement
+ const getlocal = Wwws.initlocaldata(
+ req.params.tribe,
+ req.params.appname,
+ req.params.pagename,
+ req.params.version,
+ req.session.header.xprofils,
+ req.session.header.xlang
+ );
+ res.status(getlocal.status).json(getlocal);
+ }
+);
+/**
+ * @api {get} /api/adminapi/wwws/buildpage/:tribe/:appname/:pagename - Create pagename
+ * @apiGroup Wwws
+ * @apiName createPagename
+ * @apiDescription Create a pagename from /appscreen/template/:pagename with
+ *
+ * @apiParams {string} tribe (adminapi,smatchit,..) to looking for
+ * @apiParams {string} appname agregate a full data referential to store localy
+ * @apiSuccess {object} contain cuurent version of the data model
+ * @apiSuccessExample {json} Success-Response:
+ * HTTP/1.1 200 OK
+ * {"status":200, "ref":"Odmdb", "msg":"datamodelversion", "data":{version}
+ */
+router.get("/buildpage/:tribe/:appname/:pagename", checkHeaders, (req, res) => {
+ console.log("pass get version localstorage");
+ const localdbf = `../../${req.params.tribe}/objects/wwws/itm/${req.params.appname}`;
+ if (!existsSync(localdbf)) {
+ return res
+ .status(404)
+ .json({ status: 404, ref: "Wwws", msg: "localdbnotfound", data: {} });
+ }
+ res
+ .status(200)
+ .json({
+ status: 200,
+ ref: "Wwws",
+ msg: "lastversion",
+ data: { version: fs.readJSONSync(localdbf).version },
+ });
+});
+
+module.exports = router;
diff --git a/apxtri/setup/apidoc_adminapi.json b/apxtri/setup/apidoc_adminapi.json
new file mode 100644
index 0000000..a1a3cc1
--- /dev/null
+++ b/apxtri/setup/apidoc_adminapi.json
@@ -0,0 +1,36 @@
+ {
+ "comment": "specific api for tribes conf have to be in conf/apidoc/apidoc_{tribe}.json run: $ tribe=smatchit yarn apidoctribe",
+ "name": "apxtri.be",
+ "version": "1.0.0",
+ "title": "apiDoc for apxtri endpoint",
+ "description": "Core api documentation that manage nation objects (Pagans, Nations, Towns, Blockchain, Tracking, Notifications, Odmdb, Tribes (management), Wwws)",
+ "url": "https://testwall-ants.ndda.fr/api",
+ "outputcoment":"pour rappel l'option output ne fonctionne pas en fichier de config ajouté dans package.json",
+ "output":"../nationchains/tribes/adminapi/www/cdn/apidoc/",
+ "input":[
+ "./middlewares",
+ "./routes"
+ ],
+ "order": [
+ "Middlewares",
+ "Odmdb",
+ "Nationchains",
+ "Pagans",
+ "Notifications"
+ ],
+ "template": {
+ "forceLanguage": "en",
+ "showRequiredLabels": true,
+ "withCompare": true,
+ "withGenerator": true,
+ "aloneDisplay": false
+ },
+ "header": {
+ "title": "Introduction",
+ "filename": "header.md"
+ },
+ "footer": {
+ "title": "Best practices",
+ "filename": "footer.md"
+ }
+ }
diff --git a/apxtri/setup/initadminapi.json b/apxtri/setup/initadminapi.json
new file mode 100644
index 0000000..1a21210
--- /dev/null
+++ b/apxtri/setup/initadminapi.json
@@ -0,0 +1,52 @@
+{
+ "tribeId": "adminapi",
+ "urlinit":["http://apx.adminapi","https://testwall-ants.ndda.fr"],
+ "idxname":{"towns":"towns","nation":"nations","pagans":"alias"},
+ "dns": [
+ "apx.adminapi"
+ ],
+ "status": "unchain",
+ "nationId": "ants",
+ "townId": "newdev",
+ "sudoUser": "phil",
+ "api": {
+ "port": 3021,
+ "activelog": [],
+ "languages": [
+ "en"
+ ],
+ "exposedHeaders": [
+ "xdays",
+ "xhash",
+ "xalias",
+ "xlang",
+ "xtribe",
+ "xapp",
+ "xuuid"
+ ],
+ "appset": {
+ "trust proxy": true
+ },
+ "json": {
+ "limit": "10mb",
+ "type": "application/json",
+ "rawBody": true
+ },
+ "bodyparse": {
+ "urlencoded": {
+ "limit": "50mb",
+ "extended": true
+ },
+ "json": {
+ "limit": "500mb"
+ }
+ }
+ },
+ "nginx": {
+ "restart": "sudo systemctl restart nginx",
+ "worker_connections": 1024
+ },
+ "emailcontact": "",
+ "smtp": {},
+ "sms": {}
+}
\ No newline at end of file
diff --git a/apxtri/setup/nginx.maincf b/apxtri/setup/nginx.maincf
new file mode 100644
index 0000000..1a7544e
--- /dev/null
+++ b/apxtri/setup/nginx.maincf
@@ -0,0 +1,42 @@
+user {{sudoUser}};
+worker_processes auto;
+error_log /var/log/nginx/error.log notice;
+pid /var/run/nginx.pid;
+#include /etc/nginx/modules-enabled/*.conf;
+
+events {
+ worker_connections 1024;
+}
+http {
+ include /etc/nginx/mime.types;
+ default_type application/octet-stream;
+
+ log_format main '$time_iso8601###$status###$request';
+
+ log_format tracker escape=json
+ '{"time":"$time_iso8601","alias":"$arg_alias","uuid":"$arg_uuid",'
+ '"lg":"$arg_lg","consentcookie":"$arg_consentcookie","version":"$arg_version",'
+ '"srckey":"$arg_srckey","request_filename":"$request_filename",'
+ '"remoteaddr":"$remote_addr","httpxforwardedfor":"$http_x_forwarded_for",'
+ '"httpreferer":"$http_referer","httpuseragent":"$http_user_agent","request":"$request"}';
+
+ log_format mainold '$remote_addr - $remote_user [$time_local] "$request" '
+ '$status $body_bytes_sent "$http_referer" '
+ '"$http_user_agent" "$http_x_forwarded_for"';
+
+ sendfile on;
+ keepalive_timeout 65;
+ gzip on;
+ gzip_vary on;
+ gzip_proxied any;
+ gzip_comp_level 6;
+ gzip_buffers 4 32k;
+ gzip_http_version 1.1;
+ gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript application/x-font-ttf application/javascript font/eot font/opentype image/svg+xml image/x-icon text/plain;
+
+ ##
+ # Virtual Host Configs
+ ##
+ include /etc/nginx/conf.d/*.conf;
+ include {{townpath}}/*/*/nginx/*.conf;
+}
diff --git a/apxtri/setup/nginx.wwwscf b/apxtri/setup/nginx.wwwscf
new file mode 100644
index 0000000..f8d7344
--- /dev/null
+++ b/apxtri/setup/nginx.wwwscf
@@ -0,0 +1,98 @@
+erver {
+server_name {{website}}.{{tribe}};
+add_header 'Access-Control-Allow-Origin' '*' always;
+add_header 'Access-Control-Allow-Credentials' 'true' always;
+add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, OPTIONS' always;
+add_header 'Access-Control-Allow-Headers' '*' always;
+# usefull to debug nginx conf 3 next line:
+access_log {{townpath}}/{{tribe}}/logs/nginx/{{tribe}}_{{website}}.access.log main;
+error_log {{townpath}}/{{tribe}}/logs/nginx/{{tribe}}_{{website}}.error.log debug;
+add_header xdebug "testmsg debug: $uri - $request - liste args: $args - url:$arg_url - alias:$arg_alias " always;
+
+set $trackme 0;
+if ( $uri ~ ^/trk/ ){
+ set $trackme 1;
+}
+access_log {{townpath}}/{{tribe}}/logs/nginx/{{tribe}}_{{website}}.trk.log tracker if=$trackme ;
+location ~* /trk/ {
+ if ( $uri ~ ^/trk/redirect ){
+ return 301 $arg_url;
+ }
+ rewrite ^/trk/(.*)$ /$1;
+}
+location /adminapi/Checkjson.js {
+ alias {{townpath}}/adminapi/apxtri/models/Checkjson.js;
+}
+location ~* /adminapi/objects/tplstrings/ {
+ rewrite /adminapi/objects/tplstrings/(.*$) /$1 break;
+ root {{townpath}}/adminapi/objects/tplstrings/;
+}
+location ~* /adminapi/schema/ {
+ rewrite /adminapi/schema/(.*$) /$1 break;
+ root {{townpath}}/adminapi/schema/;
+}
+location ~* /{{tribe}}/objects/tplstrings/ {
+ rewrite /{{tribe}}/objects/tplstrings/(.*$) /$1 break;
+ root {{townpath}}/{{tribe}}/objects/tplstrings/;
+}
+location ~* /{{tribe}}/schema/ {
+ rewrite /{{tribe}}/schema/(.*$) /$1 break;
+ root {{townpath}}/{{tribe}}/schema/;
+}
+location ~* /objectimg/.*/img/ {
+ rewrite /objectimg/(.*) /$1 break;
+ root {{townpath}}/{{tribe}}/objects/;
+}
+
+location /cdn/ {
+ expires 1y;
+ add_header Cache-Control "public";
+ rewrite /cdn/(.*$) /$1 break;
+ root {{townpath}}/{{tribe}}/objects/wwws/cdn/;
+}
+
+location /api/ {
+ rewrite /api/(.*$) /$1 break;
+ proxy_pass http://localhost:3020;
+ proxy_redirect off;
+ include proxy_params;
+}
+
+location /socket/ {
+ proxy_pass http://127.0.0.1:3030;
+ proxy_http_version 1.1;
+ proxy_set_header Upgrade $http_upgrade;
+ proxy_set_header Connection 'upgrade';
+ proxy_set_header Host $host;
+ proxy_cache_bypass $http_upgrade;
+}
+
+location /apxwebapp/ {
+ rewrite /apxwebapp/(.*$) /$1 break;
+ root /media/phil/usbfarm/apxtowns/apxwebapp;
+ index index.html index_fr.html index_en.html;
+}
+location /apidoc/ {
+ root {{townpath}}/{{tribe}}/objects/wwws/apidoc/;
+ index index.html;
+}
+location /appbuilder/{
+ root {{townpath}}/ndda/objects/wwws/;
+}
+location /src/ {
+rewrite /src/(.*$) /$1 break;
+root {{townpath}}/{{tribe}}/objects/wwws/{{website}}/src/;
+index index.html index_fr.html;
+}
+location / {
+root {{townpath}}/{{tribe}}/objects/wwws/{{website}}/dist/;
+index index.html index_fr.html;
+}
+error_page 404 /404.html;
+# redirect server error pages to the static page /50x.html
+#
+error_page 500 502 503 504 /50x.html;
+location = /50x.html {
+root /usr/local/nginx/html;
+}
+}
\ No newline at end of file
diff --git a/backup.sh b/backup.sh
new file mode 100644
index 0000000..9c0a8e7
--- /dev/null
+++ b/backup.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# backup each night
+# param $1 path to town name
+# param $2 tribe name
+# param $3 mainfolder that contain folderlist store this in tribe/backup/mainfolder.ter.gz
+# param $4 prefix special keyword dayname is convert to $(date +%A)
+# param $5 folderlist split by a space in doublequote "folder1 folder2"
+#
+# Exemple:
+# For setup
+#. /media/phil/usbfarm/apxtowns/dev-ants/adminapi/backup.sh /media/phil/usbfarm/apxtowns/dev-ants adminapi objects setup. "nations options pagans towns tplstrings wwws"
+#. /media/phil/usbfarm/apxtowns/dev-ants/adminapi/backup.sh /media/phil/usbfarm/apxtowns/dev-ants adminapi apxtri setup. "middlewares models routes apidoc_adminapi.json apxchat.js apxtri.js package.json"
+# For backup
+#. /media/phil/usbfarm/apxtowns/dev-ants/adminapi/backup.sh /media/phil/usbfarm/apxtowns/dev-ants adminapi objects dayname "persons"
+#
+#
+# add in crontab each day at 2h00 with echo "0 2 * * ${pathtown}/${town}/adminapi/backup.sh ${pathtown}/${town} ${tribe} objects setup. \"list of object to backup\"" | crontab -
+# add in crontab each day at 2h10 with echo "10 2 * * ${pathtown}/${town}/adminapi/backup.sh ${pathtown}/${town} ${tribe} objects $(date +A%) \"list of object to backup\"" | crontab -
+# add it for setup at least
+
+pathtown=$1
+tribe=$2
+mainfolder=$3
+prefix=$4
+if [ "$prefix" = "dayname" ]; then
+ prefix=$(date +%A)
+fi
+folderlist=$5
+# setup adminapi/objects
+declare -a folders=($folderlist)
+cd ${pathtown}
+lstfile=""
+for folder in "${folders[@]}"; do
+ lstfile="${lstfile} ${tribe}/${mainfolder}/${folder}"
+done
+tar -czf ${tribe}/backups/${prefix}.${mainfolder}.tar.gz ${lstfile}
diff --git a/package.json b/package.json
new file mode 100755
index 0000000..03fbdcf
--- /dev/null
+++ b/package.json
@@ -0,0 +1,98 @@
+{
+ "name": "adminapi",
+ "version": "1.0.0",
+ "logo": {
+ "file": "objects/wwws/cdn/share/logo/logocarredark.png"
+ },
+ "description": "apxtri Decentralized Autonomous Organization",
+ "main": "./apxtri/apxtri.js",
+ "repository": {
+ "url": "https://gitea.ndda.fr/apxtri/adminapi.git",
+ "type": "git"
+ },
+ "scripts": {
+ "startapx": "pm2 start apxtri.js --log-date-format 'DD-MM HH:mm:ss.SSS'",
+ "restartapx": "pm2 restart apxtri.js --log-date-format 'DD-MM HH:mm:ss.SSS'",
+ "dev": "NODE_MODE=dev node ./apxtri/apxtri.js",
+ "unittest": "node unittest.js",
+ "tar2prod": "rm ../objects/wwws/cdn/share/apxtriV* && tar -czf ../objects/wwws/cdn/share/apxtriV$version.tar --exclude='node_modules' --exclude='.git' ../../adminapi/apxtri ../../adminapi/schema ../../adminapi/objects ../../adminapi/template ../../adminapi/objects/tribes/itm/adminapi.json",
+ "apidoc": "apidoc -c ../../$tribe/apxtri/apidoc_$tribe.json -o ../../$tribe/objects/wwws/apidoc/",
+ "publishtestwall": "scp -r /media/phil/usbfarm/apxtowns/dev-ants/tribes/$space phil@wall-ants://home/phil/apxtowns/testwall-ants/tribes/$space/..",
+ "publishwall": "scp -r /media/phil/usbfarm/apxtowns/dev-ants/tribes/$space phil@wall-ants://home/phil/apxtowns/wall-ants/tribes/$space/..",
+ "publishhouse": "scp -r /media/phil/usbfarm/apxtowns/dev-ants/tribes/$space phil@house-ants://home/phil/apxtowns/house-ants/tribes/$space/..",
+ "src:css": "tailwindcss --watch -c ../../$tribe/objects/wwws/$webapp/tailwind.config.js -i ../../$tribe/objects/wwws/$webapp/src/static/css/twdevstyle.css -o ../../$tribe/objects/wwws/$webapp/src/static/css/twstyle.css",
+ "dist:css": "tailwindcss --minify -i ../../$tribe/objects/wwws/$webapp/src/static/css/twdevstyle.css -o ../../$tribe/objects/wwws/$webapp/dist/static/css/twstyle.css"
+ },
+ "commentscript": "cf wiki apxtri doc for details: yarn startpm2 -n teswallants, yarn pm2 stop testwallants, yarn pm2 delete testwallants, yarn pm2 logs --lines 200 testwall, yarn pm2 monit -n testwallants, yarn pm2 save tribe=tribeid yarn apidoc to build apidoc // space=adminapi/www/cdn/apidoc yarn publishtestwall ",
+ "commentinstallprod": "A lancer en yarn 'version=1 yarn run tar2prod' pour generer un tar d'installation disponible en ligne sur towndns/cdn/share/apxtriV.tar pour install voir le readme qui run in apxtowns mkdir newtown && tar -xf appv1.tar -C newtown",
+ "maintainers": [
+ {
+ "name": "Filou",
+ "email": "support@need-data.com",
+ "url": "https://need-data.com"
+ }
+ ],
+ "contributors": [
+ {
+ "name": "Antonin Hattabe",
+ "email": "",
+ "url": ""
+ },
+ {
+ "name": "Maxime Serrato",
+ "email": "",
+ "url": ""
+ },
+ {
+ "name": "Charles Filuzeau",
+ "email": "",
+ "url": ""
+ }
+ ],
+ "author": {
+ "name": "patma",
+ "email": "patma@mail.be",
+ "url": ""
+ },
+ "license": "MIT",
+ "dependencies": {
+ "@editorjs/editorjs": "^2.26.5",
+ "@google/generative-ai": "^0.11.3",
+ "apidoc": "^0.54.0",
+ "async": "^3.2.0",
+ "axios": "^1.6.2",
+ "baunsu": "^0.2.3",
+ "bcrypt": "^5.0.0",
+ "cors": "^2.8.4",
+ "crypto-js": "^4.1.1",
+ "dayjs": "^1.11.7",
+ "dns-sync": "^0.2.1",
+ "express": "^4.16.3",
+ "faiss-node": "^0.5.1",
+ "formidable": "^2.1.1",
+ "fs-extra": "^11.1.0",
+ "glob": "^7.1.2",
+ "hosts": "^0.0.1",
+ "jszip": "^3.7.1",
+ "jwt-simple": "^0.5.1",
+ "luxon": "^2.1.1",
+ "moment": "^2.22.1",
+ "mustache": "^2.3.0",
+ "nodemailer": "^6.9.7",
+ "openpgp": "^5.10.1",
+ "path": "^0.12.7",
+ "pm2": "^2.10.4",
+ "readline-sync": "^1.4.10",
+ "sharp": "^0.33.4",
+ "smtp-client": "^0.4.0",
+ "stripe": "^14.4.0",
+ "uuid": "^9.0.0",
+ "yarn": "^1.22.21"
+ },
+ "devDependencies": {
+ "@tailwindcss/typography": "^0.5.13",
+ "daisyui": "^4.12.10",
+ "postcss-import": "^16.1.0",
+ "tailwindcss": "^3.4.6"
+ }
+}
diff --git a/schema/conf.json b/schema/conf.json
new file mode 100644
index 0000000..7a8e557
--- /dev/null
+++ b/schema/conf.json
@@ -0,0 +1,5 @@
+{
+ "schema":"schema/",
+ "objects":[{"name":"nations","lastversion":0},{"name":"pagans","lastversion":0},{"name":"towns","lastversion":0},{"name":"tribes","lastversion":0}],
+ "comment":"schema are in english to get translate part a /lg/schemaname_lg.json allow to replace by lg language the relevant key. Each time a modification is done in schema lastupdate take a timestamp"
+}
\ No newline at end of file
diff --git a/schema/frenchlocation.json b/schema/frenchlocation.json
new file mode 100644
index 0000000..9999fd1
--- /dev/null
+++ b/schema/frenchlocation.json
@@ -0,0 +1,63 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "$id": "/schema/frenchlocation",
+ "title": "French adresse location system from https://api-adresse.data.gouv.fr/search/?q=8+bd+du+port+massy that respect GeoCodeJSON",
+ "description": "Manage properly postal adresse",
+ "type": "object",
+ "properties": {
+ "type": {
+ "title": "Type of result found, housenumber is a physical adresse, street position at street, locality: lieud it, municipality",
+ "type": "string"
+ },
+ "housenumber":{
+ "title":"number with ince bis ter A B"
+ },
+ "street":{
+ "title":"Name of street"
+ },
+ "name": {
+ "title": "Number plaque and street name (no town)",
+ "type": "string"
+ },
+ "label": {
+ "title": "Full address description number type of street, name of street Postal code Town name",
+ "type": "string"
+ },
+ "postcode": {
+ "title": "5 numbers french Post code",
+ "pattern": "^[0-9]{5}$"
+ },
+ "citycode": {
+ "title": "code INSEE",
+ "type": "string"
+ },
+ "city": {
+ "title": "City name",
+ "type": "string"
+ },
+ "zoning":{
+ "title":"Number of kilometer around this position",
+ "type":"integer",
+ "minimum":0
+ },
+ "position": {
+ "type": "object",
+ "properties": {
+ "latitude": {
+ "type": "number",
+ "minimum": -90.0,
+ "maximum": 90.0
+ },
+ "longitude": {
+ "type": "number",
+ "minimum": -180.0,
+ "maximum": 180.0
+ }
+ }
+ },
+ "context": {
+ "title": "Contexte of this address Department number, Department Name, Region ",
+ "type": "string"
+ }
+ }
+}
diff --git a/schema/lg/httperror_en.json b/schema/lg/httperror_en.json
new file mode 100644
index 0000000..60674b6
--- /dev/null
+++ b/schema/lg/httperror_en.json
@@ -0,0 +1,275 @@
+{
+ "100": {
+ "description": "Continue",
+ "examples": [
+ "Continue with the data transfer.",
+ "You may proceed with the next part of the request.",
+ "The server is ready for the next step in the request."
+ ]
+ },
+ "101": {
+ "description": "Switching Protocols",
+ "examples": [
+ "The server is changing the protocol on the request.",
+ "The protocol used for this request is being upgraded.",
+ "Switching to a different communication protocol."
+ ]
+ },
+ "200": {
+ "description": "OK",
+ "examples": [
+ "The operation was successful.",
+ "The request has been successfully completed.",
+ "Everything is fine, and the request is successful."
+ ]
+ },
+ "201": {
+ "description": "Created",
+ "examples": [
+ "A new resource has been successfully created.",
+ "The request resulted in the creation of a new resource.",
+ "Your request has led to the creation of a new item."
+ ]
+ },
+ "202": {
+ "description": "Accepted",
+ "examples": [
+ "The request has been accepted for processing.",
+ "Your request has been acknowledged and queued for processing.",
+ "We've received your request and will take action."
+ ]
+ },
+ "204": {
+ "description": "No Content",
+ "examples": [
+ "The request was successful, but there is no response body.",
+ "Your request was processed, but there's nothing to show in the response.",
+ "This request did not return any content."
+ ]
+ },
+ "206": {
+ "description": "Partial Content",
+ "examples": [
+ "The server is returning part of the requested data.",
+ "You requested a range of data, and we're sending a portion of it.",
+ "Here's a partial response to your request."
+ ]
+ },
+ "300": {
+ "description": "Multiple Choices",
+ "examples": [
+ "The request has multiple possible responses, and the user or client must choose one.",
+ "We can fulfill your request in several ways. Please choose one.",
+ "You have multiple options for the requested resource."
+ ]
+ },
+ "301": {
+ "description": "Moved Permanently",
+ "examples": [
+ "The requested resource has permanently moved to a new location.",
+ "This resource is no longer available here; it's moved to a new address.",
+ "The URL you're looking for has been permanently redirected."
+ ]
+ },
+ "302": {
+ "description": "Found",
+ "examples": [
+ "The requested resource is temporarily located at a different URL.",
+ "You can find what you're looking for at a different address for now.",
+ "The resource you want is temporarily located elsewhere."
+ ]
+ },
+ "304": {
+ "description": "Not Modified",
+ "examples": [
+ "The requested resource has not been modified since the specified time.",
+ "Your cached data is still up-to-date; there have been no changes.",
+ "The server confirms that your data is current."
+ ]
+ },
+ "400": {
+ "description": "Bad Request",
+ "examples": [
+ "The request is malformed or invalid.",
+ "Something is wrong with the request parameters.",
+ "Your request does not meet the server's requirements."
+ ]
+ },
+ "401": {
+ "description": "Unauthorized",
+ "examples": [
+ "Authentication is required, and the user or client failed to provide valid credentials.",
+ "You must log in or provide valid credentials to access this resource.",
+ "Access is restricted. Please provide valid authentication."
+ ]
+ },
+ "403": {
+ "description": "Forbidden",
+ "examples": [
+ "Access to the requested resource is forbidden.",
+ "You do not have permission to access this resource.",
+ "Sorry, but you're not allowed to access this."
+ ]
+ },
+ "404": {
+ "description": "Not Found",
+ "examples": [
+ "The requested resource does not exist on the server.",
+ "The server could not find the page you're looking for.",
+ "Sorry, but what you're searching for isn't here."
+ ]
+ },
+ "405": {
+ "description": "Method Not Allowed",
+ "examples": [
+ "The HTTP method used in the request is not allowed for the requested resource.",
+ "The server does not support the method you're trying to use.",
+ "This resource does not allow the requested HTTP method."
+ ]
+ },
+ "406": {
+ "description": "Not Acceptable",
+ "examples": [
+ "The requested resource cannot provide a response that is acceptable according to the request's headers.",
+ "We cannot provide the response you expect based on your request headers.",
+ "Sorry, but we can't fulfill your request as specified."
+ ]
+ },
+ "407": {
+ "description": "Proxy Authentication Required",
+ "examples": [
+ "Authentication is required to access the requested resource via a proxy.",
+ "To access this resource through a proxy, you must provide valid authentication.",
+ "Please provide valid credentials for proxy access."
+ ]
+ },
+ "408": {
+ "description": "Request Timeout",
+ "examples": [
+ "The server did not receive a complete request within the expected time.",
+ "Your request took too long to arrive at the server.",
+ "Sorry, your request has timed out."
+ ]
+ },
+ "409": {
+ "description": "Conflict",
+ "examples": [
+ "The request could not be completed due to a conflict with the current state of the target resource.",
+ "There's a conflict with the current state of the resource; please try again.",
+ "Sorry, there's a conflict with the requested action."
+ ]
+ },
+ "410": {
+ "description": "Gone",
+ "examples": [
+ "The requested resource is no longer available and has been intentionally removed.",
+ "The resource you're looking for is gone and will not return.",
+ "This resource has been permanently removed."
+ ]
+ },
+ "411": {
+ "description": "Length Required",
+ "examples": [
+ "The server requires a content length to be specified in the request headers.",
+ "Your request is missing a required content length header.",
+ "Please include a 'Content-Length' header in your request."
+ ]
+ },
+ "412": {
+ "description": "Precondition Failed",
+ "examples": [
+ "A precondition in the request headers was not met.",
+ "The server expected certain conditions to be met, but they were not.",
+ "Sorry, the required conditions were not fulfilled."
+ ]
+ },
+ "413": {
+ "description": "Request Entity Too Large",
+ "examples": [
+ "The request entity is too large for the server to process.",
+ "Your request body is too big for us to handle.",
+ "Please reduce the size of your request entity."
+ ]
+ },
+ "414": {
+ "description": "Request-URI Too Long",
+ "examples": [
+ "The URI provided in the request is too long for the server to process.",
+ "The URL in your request is excessively long; please shorten it.",
+ "The request URI you provided is too lengthy."
+ ]
+ },
+ "415": {
+ "description": "Unsupported Media Type",
+ "examples": [
+ "The server cannot process the request because the media type is not supported.",
+ "We cannot handle the content type you specified.",
+ "Sorry, we do not support the requested media type."
+ ]
+ },
+ "416": {
+ "description": "Requested Range Not Satisfiable",
+ "examples": [
+ "The requested range cannot be satisfied by the server.",
+ "We cannot provide the content range you requested.",
+ "Sorry, but we cannot fulfill the requested content range."
+ ]
+ },
+ "417": {
+ "description": "Expectation Failed",
+ "examples": [
+ "The server could not meet the expectations specified in the request's Expect header.",
+ "We were unable to fulfill the expectations you set in your request headers.",
+ "Sorry, but we could not meet your expectations."
+ ]
+ },
+ "500": {
+ "description": "Internal Server Error",
+ "examples": [
+ "Something went wrong on the server's end.",
+ "We apologize, but an unexpected error occurred.",
+ "The server is currently experiencing technical difficulties."
+ ]
+ },
+ "501": {
+ "description": "Not Implemented",
+ "examples": [
+ "The server does not support the functionality required to fulfill the request.",
+ "Sorry, but the requested functionality is not available on this server.",
+ "We have not implemented the feature you're looking for."
+ ]
+ },
+ "502": {
+ "description": "Bad Gateway",
+ "examples": [
+ "The server acting as a gateway or proxy received an invalid response from the upstream server.",
+ "The gateway or proxy received an unexpected response from the upstream server.",
+ "Sorry, there's an issue with the gateway or proxy."
+ ]
+ },
+ "503": {
+ "description": "Service Unavailable",
+ "examples": [
+ "The server is temporarily unavailable to handle the request.",
+ "We're currently unavailable due to maintenance; please try again later.",
+ "Sorry, the service is not available right now."
+ ]
+ },
+ "504": {
+ "description": "Gateway Timeout",
+ "examples": [
+ "The server acting as a gateway or proxy did not receive a timely response from the upstream server.",
+ "We're experiencing a timeout while waiting for the upstream server.",
+ "Sorry, but there's a timeout issue with the gateway."
+ ]
+ },
+ "505": {
+ "description": "HTTP Version Not Supported",
+ "examples": [
+ "The HTTP version used in the request is not supported by the server.",
+ "Your client is using an unsupported HTTP version; please update.",
+ "Sorry, but we do not support the HTTP version used in your request."
+ ]
+ }
+ }
+
\ No newline at end of file
diff --git a/schema/lg/nations_fr.json b/schema/lg/nations_fr.json
new file mode 100644
index 0000000..7e37087
--- /dev/null
+++ b/schema/lg/nations_fr.json
@@ -0,0 +1,19 @@
+{
+ "title": "Description d'une nation",
+ "description":"Nation schema in the apxtri world",
+ "$comment":"",
+ "properties":{
+ "nationId":{
+ "title":"Nom de nation",
+ "description":"Nom unique idenbtifiant une nation composé de a-z et de 0-9 permet de fereder des règles de fonctionnement"
+ },
+ "dtcreate":{
+ "title":"Date de creation",
+ "description":"Creation de la nation"
+ },
+ "contracts":{
+ "title":"Le contrat social",
+ "description":"Indique l'emplacement du contrat qu'accepte toutes les villes"
+ }
+ }
+}
\ No newline at end of file
diff --git a/schema/lg/pagans_fr.json b/schema/lg/pagans_fr.json
new file mode 100644
index 0000000..d3d09a6
--- /dev/null
+++ b/schema/lg/pagans_fr.json
@@ -0,0 +1,14 @@
+{
+ "title": "L'identité d'un pagan",
+ "description": "Decrit les informations de l'identité numérique public",
+ "properties": {
+ "publickey": {
+ "title": "Clé public associés à l'alias",
+ "description": "Cle public généré par openpgp.js lors de la creation d'un compte"
+ },
+ "alias": {
+ "title": "Alias",
+ "description": "Chaine de texte memnotechnique qui se retiens plus facilement qu'une clé public"
+ }
+ }
+}
diff --git a/schema/nations.json b/schema/nations.json
new file mode 100644
index 0000000..f08c616
--- /dev/null
+++ b/schema/nations.json
@@ -0,0 +1,39 @@
+{
+ "$schema":"http://json-schema.org/schema#",
+ "$id":"adminapi/schema/nations",
+ "title": "Nation definition",
+ "description": "A nation from apxtri world",
+ "$comment":"see ./lg/nations_lg.json for description in your languange lg",
+ "type": "object",
+ "properties": {
+ "nationId": {
+ "title":"Unique nation name",
+ "description":"A unique string that define a nation a-z and 0-9 onlyin a social world",
+ "type": "string",
+ "pattern":"^[a-z0-9]*$"
+ },
+ "dtcreate": {
+ "title":"Creation date",
+ "description":"Nation date of creation",
+ "type": "string",
+ "format":"date-time"
+ },
+ "contracts":{
+ "title":"Social contract of the nation",
+ "description":"A uri of the signed js contract that rules this nation",
+ "type": "string",
+ "format":"uri"
+ }
+ },
+ "required": ["nationId", "dtcreate","contracts"],
+ "additionalProperties":false,
+ "apxid":"nationId",
+ "apxuniquekey":["nationId"],
+ "apxidx": [
+ { "name":"lst_nationId","type":"array","keyval": "nationId"},
+ { "name":"nations","type":"view","keyval":"nationId","objkey":[],"filter":""}
+ ],
+ "apxaccessrights":{
+ "pagan":{"C":[],"R":[]}
+ }
+}
diff --git a/schema/pagans.json b/schema/pagans.json
new file mode 100644
index 0000000..520d2d4
--- /dev/null
+++ b/schema/pagans.json
@@ -0,0 +1,52 @@
+{
+ "$id": "https://smatchit.io/schema/pagan",
+ "$comment": "To create account bin apxtri",
+ "title": "Pagans identity",
+ "description": "A numeric id in the nationchains world",
+ "type": "object",
+ "properties": {
+ "publickey": {
+ "title": "Alias's publickey",
+ "description": "Public key generate with openpgp.js",
+ "type": "string",
+ "format": "pgppublickey"
+ },
+ "alias": {
+ "title": "Alias",
+ "description": "text to remember easily a public key",
+ "type": "string",
+ "minLength": 3,
+ "pattern": "^[a-z0-9]*$"
+ },
+ "dt_delete": {
+ "title": "Date of death",
+ "description": "Date of alias delete request, your will will be apply",
+ "type": "string",
+ "format": "date-time"
+ },
+ "will": {
+ "title": "Will script after death",
+ "description": "This will script will be apply on your data 30 days after your alias death",
+ "type": "string"
+ }
+ },
+ "required": ["publickey", "alias"],
+ "apxid": "alias",
+ "apxuniquekey": ["publickey"],
+ "apxidx": [
+ { "name": "lst_alias", "type": "array", "keyval": "alias" },
+ {
+ "name": "alias",
+ "type": "view",
+ "keyval": "alias",
+ "objkey": [],
+ "filter": ""
+ }
+ ],
+ "apxaccessrights": {
+ "owner": { "R": [], "U": [], "D": [] },
+ "anonymous": { "C": [], "R": ["alias"] },
+ "pagans": { "R": ["alias", "publickey"] },
+ "mayor": { "R": [], "D": [] }
+ }
+}
diff --git a/schema/screens.json b/schema/screens.json
new file mode 100644
index 0000000..27fe61f
--- /dev/null
+++ b/schema/screens.json
@@ -0,0 +1,69 @@
+{
+ "$id": "https://smatchit.io/schema/screens",
+ "$comment": "To describe screens as tree to navigate inside",
+ "title": "Screens description",
+ "description": "Each propertie value is a mustache template string where a data must be provide to display screen with value",
+ "type": "object",
+ "properties": {
+ "screenid":{
+ "title":"Screen identification used in html tag id",
+ "type":"string"
+ },
+ "title": {
+ "title": "A title in a screen",
+ "type": "string"
+ },
+ "subtitle": {
+ "title": "A subtitle in a screen",
+ "type": "string"
+ },
+ "icon": {
+ "title": "an icon name",
+ "type": "string"
+ },
+ "warning": {
+ "title": "A text to highlight something, this text is between 2 ! icon",
+ "type": "string"
+ },
+ "formcontrol": {
+ "title": "A key word to presents this content",
+ "type": "string",
+ "enum":["squarebluebtn","listbtn","form"]
+ },
+ "forms":{
+ "title":"Liste of data collection element into the screen",
+ "type":"array",
+ "items":{"type":"objects"}
+ },
+ "action": {
+ "title": "List of possible action on this element",
+ "type": "string",
+ "enum":["onclick"]
+ },
+ "function":{
+ "title":"Function name to call, if action",
+ "comment":"other function than nextlevel",
+ "type":"string"
+ },
+ "params":{
+ "title":" an object containning parameter to send to function",
+ "comment":"can be empty {}",
+ "type":"objects"
+ },
+ "nextlevel":{
+ "title":"List of new screens to show if function is nextlevel $ref:# means it same current schema",
+ "type":"array",
+ "items":{"$ref":"#"}
+ }
+ },
+ "required": ["screenid", "title"],
+ "apxid": "screenid",
+ "apxuniquekey": ["screenid"],
+ "apxidx": [
+ { "name": "lst_screens", "type": "array", "keyval": "screenid" },
+ ],
+ "apxaccessrights": {
+ "owner": { "R": [], "U": [], "D": [] },
+ "anonymous": { "R": [] },
+ }
+ }
diff --git a/schema/towns.json b/schema/towns.json
new file mode 100644
index 0000000..410ee39
--- /dev/null
+++ b/schema/towns.json
@@ -0,0 +1,88 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "$id": "schema/towns",
+ "title": "Town",
+ "description": "A town belonging to a nation from apxtri world",
+ "type": "object",
+ "properties": {
+ "townId": {
+ "type": "string",
+ "pattern": "^[a-z0-9]*$"
+ },
+ "nationId": {
+ "type": "string",
+ "options": {
+ "$ref": "adminapi/objects/nations/idx/lst_nations.json"
+ }
+ },
+ "owner": {
+ "type": "string",
+ "options": {
+ "$ref": "adminapi/objects/pagans/idx/lst_alias.json"
+ }
+ },
+ "mayorId": {
+ "comment": "todo, to be remove by ower in models",
+ "type": "string",
+ "options": {
+ "$ref": "adminapi/objects/pagans/idx/lst_alias.json"
+ }
+ },
+ "IP": {
+ "comment": "IP adress where the dns answer to access in direct to this IP into a /etc/hosts or private dns",
+ "type": "string"
+ },
+ "status": {
+ "title": "The current status of this town",
+ "description": "Unchain is used for dev they are no public domain, chain means that a public domain name is available, elected means the consensus make this town as the master of adminapi data. A town is elected for a period of time necessary to get new election",
+ "default": "unchain",
+ "type": "string",
+ "enum": [
+ "unchain",
+ "chain",
+ "elected"
+ ]
+ },
+ "dns": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "townId",
+ "status",
+ "nationId",
+ "dns"
+ ],
+ "apxid": "townId",
+ "apxuniquekey": [
+ "townId",
+ "dns"
+ ],
+ "apxidx": [
+ {
+ "name": "lst_townId",
+ "type":"array",
+ "keyval": "townId"
+ },
+ {
+ "name": "towns",
+ "keyval": "townId",
+ "type": "view",
+ "objkey": [],
+ "filter": ""
+ }
+ ],
+ "apxaccessrights": {
+ "pagan": {
+ "C": [],
+ "R": []
+ },
+ "owner": {
+ "D": [],
+ "U": [
+ "owner",
+ "status"
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/schema/tribes.json b/schema/tribes.json
new file mode 100644
index 0000000..4044cb0
--- /dev/null
+++ b/schema/tribes.json
@@ -0,0 +1,110 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "$id": "nationchains/schema/tribes",
+ "title": "Tribes",
+ "description": "A tribe belonging to a town",
+ "type": "object",
+ "properties": {
+ "tribeId": {
+ "type": "string",
+ "pattern": "^[a-z0-9]*$"
+ },
+ "townId": {
+ "type": "string",
+ "options": {
+ "$ref": "adminapi/objects/towns/idx/lst_towns.json"
+ }
+ },
+ "nationId": {
+ "type": "string",
+ "options": {
+ "$ref": "adminapi/objects/nations/idx/lst_nations.json"
+ }
+ },
+ "owner": {
+ "type": "string",
+ "options": {
+ "$ref": "adminapi/objects/nations/idx/lst_alias.json"
+ }
+ },
+ "dns": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "context": {
+ "type": "object",
+ "comments": "Check if necessary generate by apxtri.js detail route model available"
+ }
+ },
+ "required": [
+ "townId",
+ "status",
+ "nationId",
+ "dns"
+ ],
+ "apxid": "tribeId",
+ "apxuniquekey": [
+ "tribeId"
+ ],
+ "apxidx": [
+ {
+ "name": "lst_tribeId",
+ "keyval": "tribeId",
+ "type": "array"
+ },
+ {
+ "name": "tribes",
+ "keyval": "tribeId",
+ "type": "view",
+ "objkey": [],
+ "filter": ""
+ },
+ {
+ "name": "owner_tribeId",
+ "type": "distribution",
+ "keyval": "owner",
+ "objkey": [
+ "tribeId"
+ ]
+ },
+ {
+ "name": "dns_tribeId",
+ "type": "distribution",
+ "keyval": "dns",
+ "objkey": [
+ "tribeId"
+ ]
+ },
+ {
+ "name": "tribes_dns",
+ "keyval": "tribeId",
+ "type": "view",
+ "objkey": [
+ "dns"
+ ],
+ "filter": ""
+ }
+ ],
+ "apxacceesrights": {
+ "owner": {
+ "D": [],
+ "U": [
+ "owner",
+ "dns"
+ ]
+ },
+ "druid": {
+ "R": [],
+ "U": []
+ },
+ "mayor": {
+ "C": [],
+ "R": []
+ },
+ "pagan": {
+ "R": []
+ }
+ }
+}
\ No newline at end of file
diff --git a/schema/wwws.json b/schema/wwws.json
new file mode 100644
index 0000000..1bf9552
--- /dev/null
+++ b/schema/wwws.json
@@ -0,0 +1,131 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "$id": "nationchains/schema/www",
+ "title": "www",
+ "description": "A space web available for a domaine, with accessright",
+ "type": "object",
+ "properties": {
+ "tribeId": {
+ "title": "Tribe name",
+ "description": "A unique string as tribe",
+ "options": {
+ "$ref": "adminapi/objects/tribess/idx/lst_tribeId.json"
+ }
+ },
+ "website": {
+ "description": "Folder name into a tribeId/www/",
+ "title": "web space",
+ "type": "string"
+ },
+ "status": {
+ "title": "Status",
+ "description": "Status of website ",
+ "default": "active",
+ "type": "string",
+ "enum": [
+ "chain",
+ "tochain",
+ "unchain"
+ ]
+ },
+ "dns": {
+ "title": "domaine name list to access",
+ "description": "Add in nginx nameserver local website.tribeId LAN domaine.tld",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "apxtri": {
+ "title": "apxtri value to use in a front end project",
+ "type": "object",
+ "properties": {
+ "headers": {
+ "type": "object",
+ "properties": {
+ "xtrkversion": {
+ "type": "integer",
+ "default": 1
+ },
+ "xalias": {
+ "type": "string",
+ "default": "anonymous"
+ },
+ "xapp": {
+ "type": "string",
+ "comment": "the website"
+ },
+ "xdays": {
+ "type": "integer",
+ "default": 0
+ },
+ "xhash": {
+ "type": "string",
+ "default": "anonymous"
+ },
+ "xlang": {
+ "type": "string",
+ "default": "en"
+ },
+ "xprofils": {
+ "type": "string",
+ "default": "anonymous"
+ },
+ "xtribe": {
+ "type": "string",
+ "comment": "the tribeid"
+ },
+ "xuuid": {
+ "type": "string""default": 0
+ }
+ },
+ "required": [
+ "xtrkversion",
+ "xalias",
+ "xapp",
+ "xdays",
+ "xhash",
+ "xlang",
+ "xprofils",
+ "xtribe",
+ "xuuid"
+ ]
+ }
+ },
+ "required": [
+ "headers"
+ ]
+ },
+ "pages": {
+ "title": "a page name of a front end",
+ "description": "Those obejct allow to run a request like https://dns[]/api/adminapi/localdb(anonymous|)/tribeId/website/pagesname/version to return some contexte items are collection of object items @todo explain list of possible",
+ "type": "object"
+ }
+ },
+ "required": [
+ "tribeId",
+ "website",
+ "status"
+ ],
+ "apxid": "website",
+ "apxidx": [
+ {
+ "name": "lst_website",
+ "type": "array",
+ "keyval": "website"
+ }
+ ],
+ "apxaccessrights": {
+ "owner": {
+ "D": [],
+ "R": [],
+ "U": []
+ },
+ "mayor": {
+ "C": []
+ },
+ "person": {
+ "R": []
+ }
+ }
+}
\ No newline at end of file
diff --git a/template/createidentity_en.js b/template/createidentity_en.js
new file mode 100644
index 0000000..85522b8
--- /dev/null
+++ b/template/createidentity_en.js
@@ -0,0 +1,100 @@
+// See https://nodemailer.com/message/ for available fields to add
+// email template to get key registration
+const tplemail={};
+tplemail.sender = "smatchtit"
+tplemail.replyTo="{{{name}}}<{{{email}}}>"
+tplemail.inreplyTo=""
+tplemail.references=""
+//tplemail.from = "noreply@smatchit.io" get by default in configtrib.emailcontact or server ;emailcontact
+tplemail.to="<{{emailcontact}}>"
+tplemail.subject="Vos clés d'identification pour {{alias}}"
+tplemail.cc=""
+tplemail.bcc=""
+tplemail.attachments=[]
+/*example
+ attachments: [
+ {
+ filename: "{{data}}.txt",
+ pathfile: "{{data}}",
+ contenttype: "text/plain",
+ minepart: "mixed",
+ },
+ {
+ filename: "my-image.jpg",
+ content: "blabla content",
+ contenttype: "image/jpeg",
+ minepart: "alternative",
+ },
+ ],
+ if content and filepath is present filepath content replace content
+ */
+tplemail.html=`
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ Votre identité numérique: {{alias}}
+ Vous avez souhaité recevoir vos clés d'identification via {{tribe}}. Une identité numerique est composée de 2 fichiers texte appelés clé privée et clé public.
+
+ Son usage est simple mais souvent méconnu, avec une fonction mathematique, la clé privée permet de signer un message. Avec une autre fonction, on vérifie que la signature est bien issue de la cle public sans avoir besoin de disposer de la clé privée.
+
+ Les applications de {{tribe}} fonctionnent toutes de cette façon et permettent non seulement de vous identifier mais aussi de chiffrer vos données lisible uniquement grâce à votre clé privée. Pour simplifier l'usage de ces clés nous associons un alias à votre clé public.
+ {{#avecpassphrase}}
+
+ Pour plus de securité, on peut vous demander une passphrase qui dans votre cas est :{{passphrase}}
+
+ {{/avecpassphrase}}
+ Gardez précieusement ces clés et ne communiquez jamais votre clé privée. Uniquement votre alias (et eventuellement votre clé public).
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ Nos conditions d'utilisation et politique de protection des données CGU
+
+
+
+
+
+
+`
+tplemail.text=`
+Vos clés d'authentifications:
+alias: {{alias}}
+passphrase: {{passphrase}}
+publickey: copier coller entre les 2 lignes -------
+---------------------
+{{publickey}}
+---------------------
+privatekye: copier coller entre les 2 lignes -------
+---------------------
+{{privatekey}}
+---------------------
+`
+module.exports=tplemail;
\ No newline at end of file
diff --git a/template/createidentity_fr.js b/template/createidentity_fr.js
new file mode 100644
index 0000000..d6bc43b
--- /dev/null
+++ b/template/createidentity_fr.js
@@ -0,0 +1,100 @@
+// See https://nodemailer.com/message/ for available fields to add
+// email template to get key registration
+const tplemail={};
+tplemail.sender = "smatchtit"
+tplemail.replyTo="{{{name}}}<{{{email}}}>"
+tplemail.inreplyTo=""
+tplemail.references=""
+//tplemail.from = "noreply@smatchit.io" get by default in configtrib.emailcontact or server ;emailcontact
+tplemail.to="<{{emailcontact}}>"
+tplemail.subject="Vos clés d'identification pour {{alias}}"
+tplemail.cc=""
+tplemail.bcc=""
+tplemail.attachments=[]
+/*example
+ attachments: [
+ {
+ filename: "{{data}}.txt",
+ pathfile: "{{data}}",
+ contenttype: "text/plain",
+ minepart: "mixed",
+ },
+ {
+ filename: "my-image.jpg",
+ content: "blabla content",
+ contenttype: "image/jpeg",
+ minepart: "alternative",
+ },
+ ],
+ if content and filepath is present filepath content replace content
+ */
+tplemail.html=`
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Votre identité numérique: {{alias}}
+ Vous avez souhaité recevoir vos clés d'identification via {{tribe}}. Une identité numerique est composée de 2 fichiers texte appelés clé privée et clé public.
+
+ Son usage est simple mais souvent méconnu, avec une fonction mathematique, la clé privée permet de signer un message. Avec une autre fonction, on vérifie que la signature est bien issue de la cle public sans avoir besoin de disposer de la clé privée.
+
+ Les applications de {{tribe}} fonctionnent toutes de cette façon et permettent non seulement de vous identifier mais aussi de chiffrer vos données lisible uniquement grâce à votre clé privée. Pour simplifier l'usage de ces clés nous associons un alias à votre clé public.
+ {{#avecpassphrase}}
+
+ Pour plus de securité, on peut vous demander une passphrase qui dans votre cas est :{{passphrase}}
+
+ {{/avecpassphrase}}
+ Gardez précieusement ces clés et ne communiquez jamais votre clé privée. Uniquement votre alias (et eventuellement votre clé public).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Nos conditions d'utilisation et politique de protection des données CGU
+
+
+
+
+
+
+`
+tplemail.text=`
+Vos clés d'authentifications:
+alias: {{alias}}
+passphrase: {{passphrase}}
+publickey: copier coller entre les 2 lignes -------
+---------------------
+{{publickey}}
+---------------------
+privatekye: copier coller entre les 2 lignes -------
+---------------------
+{{privatekey}}
+---------------------
+`
+module.exports=tplemail;
\ No newline at end of file