@indos/bibliotheque 2.4.0 → 4.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CLAUDE.md +361 -0
- package/LICENSE +4 -18
- package/README.md +6 -11
- package/bin/page-de-l-espace.js +12 -6
- package/package.json +16 -13
- package/src/app.js +2 -2
- package/src/appeler.js +4 -5
- package/src/compte.d.ts +222 -8
- package/src/compte.js +250 -22
- package/src/description-des-comptes.d.ts +16 -0
- package/src/direct/page.js +1 -1
- package/src/direct.js +1 -1
- package/src/ecran.js +2 -2
- package/src/espace/apercu.js +10 -23
- package/src/espace/cadre.d.ts +3 -5
- package/src/espace/cadre.js +29 -31
- package/src/espace/chose-seule.d.ts +1 -4
- package/src/espace/chose-seule.js +7 -16
- package/src/espace/choses.d.ts +9 -5
- package/src/espace/choses.js +9 -4
- package/src/espace/comptes.js +146 -103
- package/src/espace/coquille.d.ts +5 -5
- package/src/espace/coquille.js +93 -63
- package/src/espace/doubles-de-jsdom.js +11 -4
- package/src/espace/ecran-d-une-chose.js +10 -9
- package/src/espace/ecran.js +1 -2
- package/src/espace/edition-de-la-barre.js +35 -11
- package/src/espace/essai.js +4 -4
- package/src/espace/fenetre-du-don.d.ts +11 -0
- package/src/espace/fenetre-du-don.js +41 -0
- package/src/espace/index.d.ts +3 -3
- package/src/espace/index.js +3 -3
- package/src/espace/liste-des-choses.js +28 -24
- package/src/espace/menu-d-une-chose.js +15 -51
- package/src/espace/ouvrir.d.ts +3 -3
- package/src/espace/ouvrir.js +15 -14
- package/src/espace/panneau-du-partage.d.ts +8 -3
- package/src/espace/panneau-du-partage.js +36 -14
- package/src/espace/routes-des-choses.js +6 -5
- package/src/espace/session.d.ts +1 -0
- package/src/faux-core.d.ts +15 -3
- package/src/faux-core.js +71 -3
- package/src/fichiers.d.ts +2 -0
- package/src/fichiers.js +6 -4
- package/src/flux.js +1 -1
- package/src/format.d.ts +3 -0
- package/src/format.js +20 -1
- package/src/forme-du-direct.js +1 -1
- package/src/jeton.js +2 -2
- package/src/liens.js +1 -1
- package/src/mcp.js +3 -3
- package/src/notifier.d.ts +10 -0
- package/src/notifier.js +47 -0
- package/src/page.d.ts +17 -0
- package/src/page.js +139 -14
- package/src/partage.d.ts +5 -1
- package/src/partage.js +61 -16
- package/src/presence.js +1 -1
- package/src/sans-accents.js +1 -1
- package/src/session.js +4 -4
- package/src/theme.js +1 -1
- package/src/ui/blocs.d.ts +5 -2
- package/src/ui/blocs.js +11 -6
- package/src/ui/choix.d.ts +2 -1
- package/src/ui/choix.js +3 -2
- package/src/ui/fenetre.d.ts +8 -3
- package/src/ui/fenetre.js +34 -9
- package/src/ui/focus.d.ts +2 -0
- package/src/ui/focus.js +5 -0
- package/src/ui/gestes-du-contenu.d.ts +21 -0
- package/src/ui/gestes-du-contenu.js +24 -0
- package/src/ui/icones.d.ts +7 -0
- package/src/ui/icones.js +12 -1
- package/src/ui/index.d.ts +5 -4
- package/src/ui/index.js +4 -3
- package/src/ui/lien.d.ts +1 -0
- package/src/ui/lien.js +2 -2
- package/src/ui/menu-d-une-ligne.d.ts +2 -0
- package/src/ui/panneau.d.ts +1 -2
- package/src/ui/panneau.js +8 -4
- package/src/ui/reglages.d.ts +47 -0
- package/src/ui/reglages.js +101 -0
- package/src/ui/tableau.d.ts +1 -2
- package/src/ui/tableau.js +8 -12
- package/src/ui/vues.js +1 -1
- package/src/vite.d.ts +3 -0
- package/src/vite.js +50 -18
- package/CHANGELOG.md +0 -295
- package/bin/bibliotheque.d.ts +0 -1
- package/bin/bibliotheque.js +0 -62
- package/modeles/app-du-client/.dockerignore +0 -3
- package/modeles/app-du-client/DOCUMENTATION.md +0 -27
- package/modeles/app-du-client/Dockerfile +0 -36
- package/modeles/app-du-client/README.md +0 -53
- package/modeles/app-du-client/USAGE.md +0 -3
- package/modeles/app-du-client/espace/ecrans/entrees.tsx +0 -57
- package/modeles/app-du-client/espace/index.html +0 -9
- package/modeles/app-du-client/espace/page.tsx +0 -6
- package/modeles/app-du-client/espace/requetes/entrees.ts +0 -16
- package/modeles/app-du-client/espace/routes.ts +0 -12
- package/modeles/app-du-client/espace/tsconfig.json +0 -7
- package/modeles/app-du-client/gitignore +0 -2
- package/modeles/app-du-client/logo.svg +0 -1
- package/modeles/app-du-client/migrations/0001-creer-les-entrees.sql +0 -10
- package/modeles/app-du-client/module.json +0 -12
- package/modeles/app-du-client/package.json +0 -17
- package/modeles/app-du-client/src/demarrer.ts +0 -17
- package/modeles/app-du-client/src/outils.ts +0 -48
- package/modeles/app-du-client/src/serveur.ts +0 -46
- package/modeles/app-du-client/tests/espace/entrees.test.tsx +0 -57
- package/modeles/app-du-client/tests/serveur.test.ts +0 -119
- package/modeles/app-du-client/tests/sources-de-la-page.test.ts +0 -23
- package/modeles/app-du-client/tsconfig.json +0 -22
- package/src/ui/repli.d.ts +0 -12
- package/src/ui/repli.js +0 -6
package/src/compte.d.ts
CHANGED
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
import type { IncomingMessage, ServerResponse } from 'node:http';
|
|
2
|
-
import type
|
|
2
|
+
import type pg from 'pg';
|
|
3
|
+
import type { EtapeDecrite, EtatDUnCompte, FaitDecrit } from './description-des-comptes.ts';
|
|
3
4
|
import type { Personne } from './jeton.ts';
|
|
5
|
+
import { type Annuaire, type DroitSurLaChose, type Partage } from './partage.ts';
|
|
4
6
|
export declare function chiffrer(cle: Buffer, compte: string, texte: string): string;
|
|
5
7
|
export declare function dechiffrer(cle: Buffer, compte: string, enBase64: string): string;
|
|
6
8
|
export declare function garderLeSecret(cle: Buffer, compte: string, chiffre: string, destination: unknown[], enregistree: unknown[]): string | undefined;
|
|
@@ -21,15 +23,18 @@ export type CompteMontre<N extends string = string> = {
|
|
|
21
23
|
id: string;
|
|
22
24
|
nom: string;
|
|
23
25
|
detail?: string;
|
|
24
|
-
etats?:
|
|
25
|
-
|
|
26
|
-
sorte?: 'active' | 'erreur';
|
|
27
|
-
}[];
|
|
28
|
-
valeurs: Partial<Valeurs<N>>;
|
|
26
|
+
etats?: EtatDUnCompte[];
|
|
27
|
+
valeurs: Partial<Valeurs<N | 'nom'>>;
|
|
29
28
|
lien?: {
|
|
30
29
|
texte: string;
|
|
31
30
|
adresse: string;
|
|
32
31
|
};
|
|
32
|
+
droit?: DroitSurLaChose;
|
|
33
|
+
donnable?: boolean;
|
|
34
|
+
proprietaire?: string;
|
|
35
|
+
};
|
|
36
|
+
export type ValeursDUnCompte<N extends string = string> = Valeurs<N> & {
|
|
37
|
+
nom?: string;
|
|
33
38
|
};
|
|
34
39
|
export type OptionsDesGestes<N extends string> = {
|
|
35
40
|
adresse: string;
|
|
@@ -41,13 +46,222 @@ export type OptionsDesGestes<N extends string> = {
|
|
|
41
46
|
brancher: string;
|
|
42
47
|
retirer: string;
|
|
43
48
|
etapes?: EtapeDecrite[];
|
|
49
|
+
fournisseur?: string;
|
|
50
|
+
introduction?: string;
|
|
51
|
+
note?: string;
|
|
52
|
+
connecter?: string;
|
|
44
53
|
suites?: string[];
|
|
45
54
|
faits?: Record<string, FaitDecrit>;
|
|
55
|
+
nom?: {
|
|
56
|
+
exemple?: string;
|
|
57
|
+
aide?: string;
|
|
58
|
+
};
|
|
59
|
+
enEntier?: string;
|
|
60
|
+
sansDon?: string;
|
|
46
61
|
};
|
|
47
62
|
champs: Champ<N>[];
|
|
63
|
+
partage?: Partage;
|
|
64
|
+
apresUnDon?: (id: string) => Promise<unknown> | unknown;
|
|
48
65
|
comptesDe: (personne: Personne) => Promise<CompteMontre<NoInfer<N>>[]>;
|
|
49
|
-
brancher: (personne: Personne, valeurs:
|
|
50
|
-
|
|
66
|
+
brancher: (personne: Personne, valeurs: ValeursDUnCompte<N>) => Promise<string | {
|
|
67
|
+
connexion: string;
|
|
68
|
+
} | undefined>;
|
|
69
|
+
modifier: (personne: Personne, id: string, valeurs: ValeursDUnCompte<N>) => Promise<string | undefined>;
|
|
51
70
|
retirer: (personne: Personne, id: string) => Promise<unknown>;
|
|
52
71
|
};
|
|
53
72
|
export declare function creerLesGestesDesComptes<N extends string>(options: OptionsDesGestes<N>): (requete: IncomingMessage, reponse: ServerResponse, chemin: string) => Promise<boolean>;
|
|
73
|
+
export type OptionsDuPartageDesComptes = {
|
|
74
|
+
base: pg.Pool;
|
|
75
|
+
table: string;
|
|
76
|
+
laChose: string;
|
|
77
|
+
absente?: (id: string) => string;
|
|
78
|
+
colonnes: string;
|
|
79
|
+
detail: string;
|
|
80
|
+
ordre?: string;
|
|
81
|
+
donnable?: string;
|
|
82
|
+
adresseDuCore?: string;
|
|
83
|
+
app?: string;
|
|
84
|
+
cleDAppel?: string;
|
|
85
|
+
};
|
|
86
|
+
export type ProprietaireDUnCompte = {
|
|
87
|
+
id: string;
|
|
88
|
+
nom: string;
|
|
89
|
+
email: string;
|
|
90
|
+
active: boolean;
|
|
91
|
+
};
|
|
92
|
+
export type CompteVisible<C extends object = Record<string, unknown>> = C & {
|
|
93
|
+
id: string;
|
|
94
|
+
nom: string;
|
|
95
|
+
detail: string;
|
|
96
|
+
droit: DroitSurLaChose;
|
|
97
|
+
donnable: boolean;
|
|
98
|
+
proprietaire: ProprietaireDUnCompte;
|
|
99
|
+
};
|
|
100
|
+
export declare function creerLePartageDesComptes<C extends object = Record<string, unknown>>(options: OptionsDuPartageDesComptes): {
|
|
101
|
+
pourLaPersonne: (personne: Personne, { alias, depuis }?: {
|
|
102
|
+
alias?: string;
|
|
103
|
+
depuis?: number;
|
|
104
|
+
}) => {
|
|
105
|
+
ouverte: string;
|
|
106
|
+
droit: string;
|
|
107
|
+
valeurs: (string | string[])[];
|
|
108
|
+
};
|
|
109
|
+
trouver: <C_1 = import("./partage.ts").ChoseLue>(personne: Personne, id: unknown, { colonnes: liste, client }?: {
|
|
110
|
+
colonnes?: string;
|
|
111
|
+
client?: {
|
|
112
|
+
query: {
|
|
113
|
+
<T extends import("pg").Submittable>(queryStream: T): T;
|
|
114
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryArrayResult<R>>;
|
|
115
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryConfig: import("pg").QueryConfig<I>): Promise<import("pg").QueryResult<R>>;
|
|
116
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryResult<R>>;
|
|
117
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, callback: (err: Error, result: import("pg").QueryArrayResult<R>) => void): void;
|
|
118
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
119
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryText: string, values: import("pg").QueryConfigValues<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
120
|
+
};
|
|
121
|
+
};
|
|
122
|
+
}) => Promise<(C_1 & {
|
|
123
|
+
droit: DroitSurLaChose;
|
|
124
|
+
}) | undefined>;
|
|
125
|
+
lireLAnnuaire: ({ sansCache }?: {
|
|
126
|
+
sansCache?: boolean;
|
|
127
|
+
}) => Promise<Annuaire>;
|
|
128
|
+
schemaDeChercher(enPlus?: NonNullable<import("./mcp.ts").Outil['schema']['properties']>): import("./mcp.ts").Outil['schema'];
|
|
129
|
+
droitSur(personne: Personne, id: string): Promise<DroitSurLaChose | undefined>;
|
|
130
|
+
lire<C_1 = import("./partage.ts").ChoseLue>(personne: Personne, id: unknown, { droit, ...reste }?: {
|
|
131
|
+
droit?: DroitSurLaChose;
|
|
132
|
+
colonnes?: string;
|
|
133
|
+
client?: {
|
|
134
|
+
query: {
|
|
135
|
+
<T extends import("pg").Submittable>(queryStream: T): T;
|
|
136
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryArrayResult<R>>;
|
|
137
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryConfig: import("pg").QueryConfig<I>): Promise<import("pg").QueryResult<R>>;
|
|
138
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryResult<R>>;
|
|
139
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, callback: (err: Error, result: import("pg").QueryArrayResult<R>) => void): void;
|
|
140
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
141
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryText: string, values: import("pg").QueryConfigValues<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
142
|
+
};
|
|
143
|
+
};
|
|
144
|
+
}): Promise<C_1 & {
|
|
145
|
+
droit: DroitSurLaChose;
|
|
146
|
+
}>;
|
|
147
|
+
chercher<C_1 = import("./partage.ts").ChoseLue>(personne: Personne, arguments_: Record<string, unknown>, { colonnes: liste, condition }?: {
|
|
148
|
+
colonnes?: string;
|
|
149
|
+
condition?: (valeur: (une: unknown) => string) => string;
|
|
150
|
+
}): Promise<{
|
|
151
|
+
lignes: (C_1 & {
|
|
152
|
+
droit: DroitSurLaChose;
|
|
153
|
+
})[];
|
|
154
|
+
total: number;
|
|
155
|
+
}>;
|
|
156
|
+
ouvrirALaCreation(client: {
|
|
157
|
+
query: {
|
|
158
|
+
<T extends import("pg").Submittable>(queryStream: T): T;
|
|
159
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryArrayResult<R>>;
|
|
160
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryConfig: import("pg").QueryConfig<I>): Promise<import("pg").QueryResult<R>>;
|
|
161
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryResult<R>>;
|
|
162
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, callback: (err: Error, result: import("pg").QueryArrayResult<R>) => void): void;
|
|
163
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
164
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryText: string, values: import("pg").QueryConfigValues<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
165
|
+
};
|
|
166
|
+
}, id: string): Promise<void>;
|
|
167
|
+
partageDe(id: string): Promise<import("./partage.ts").Ouverture[]>;
|
|
168
|
+
partager(personne: Personne, id: string, arguments_: Record<string, unknown>): Promise<import("./partage.ts").Ouverture[]>;
|
|
169
|
+
nePlusPartager(personne: Personne, id: string, arguments_: Record<string, unknown>): Promise<import("./partage.ts").Ouverture[]>;
|
|
170
|
+
donner(personne: Personne, id: string, arguments_: Record<string, unknown>): Promise<{
|
|
171
|
+
id: string;
|
|
172
|
+
proprietaire: {
|
|
173
|
+
nom: string;
|
|
174
|
+
email: string;
|
|
175
|
+
};
|
|
176
|
+
partage: import("./partage.ts").Ouverture[];
|
|
177
|
+
}>;
|
|
178
|
+
donnerLesChoses(personne: Personne, arguments_: Record<string, unknown>): Promise<import("./partage.ts").ChosesDonnees>;
|
|
179
|
+
partage: {
|
|
180
|
+
pourLaPersonne: (personne: Personne, { alias, depuis }?: {
|
|
181
|
+
alias?: string;
|
|
182
|
+
depuis?: number;
|
|
183
|
+
}) => {
|
|
184
|
+
ouverte: string;
|
|
185
|
+
droit: string;
|
|
186
|
+
valeurs: (string | string[])[];
|
|
187
|
+
};
|
|
188
|
+
trouver: <C_1 = import("./partage.ts").ChoseLue>(personne: Personne, id: unknown, { colonnes: liste, client }?: {
|
|
189
|
+
colonnes?: string;
|
|
190
|
+
client?: {
|
|
191
|
+
query: {
|
|
192
|
+
<T extends import("pg").Submittable>(queryStream: T): T;
|
|
193
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryArrayResult<R>>;
|
|
194
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryConfig: import("pg").QueryConfig<I>): Promise<import("pg").QueryResult<R>>;
|
|
195
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryResult<R>>;
|
|
196
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, callback: (err: Error, result: import("pg").QueryArrayResult<R>) => void): void;
|
|
197
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
198
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryText: string, values: import("pg").QueryConfigValues<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
199
|
+
};
|
|
200
|
+
};
|
|
201
|
+
}) => Promise<(C_1 & {
|
|
202
|
+
droit: DroitSurLaChose;
|
|
203
|
+
}) | undefined>;
|
|
204
|
+
lireLAnnuaire: ({ sansCache }?: {
|
|
205
|
+
sansCache?: boolean;
|
|
206
|
+
}) => Promise<Annuaire>;
|
|
207
|
+
schemaDeChercher(enPlus?: NonNullable<import("./mcp.ts").Outil['schema']['properties']>): import("./mcp.ts").Outil['schema'];
|
|
208
|
+
droitSur(personne: Personne, id: string): Promise<DroitSurLaChose | undefined>;
|
|
209
|
+
lire<C_1 = import("./partage.ts").ChoseLue>(personne: Personne, id: unknown, { droit, ...reste }?: {
|
|
210
|
+
droit?: DroitSurLaChose;
|
|
211
|
+
colonnes?: string;
|
|
212
|
+
client?: {
|
|
213
|
+
query: {
|
|
214
|
+
<T extends import("pg").Submittable>(queryStream: T): T;
|
|
215
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryArrayResult<R>>;
|
|
216
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryConfig: import("pg").QueryConfig<I>): Promise<import("pg").QueryResult<R>>;
|
|
217
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryResult<R>>;
|
|
218
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, callback: (err: Error, result: import("pg").QueryArrayResult<R>) => void): void;
|
|
219
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
220
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryText: string, values: import("pg").QueryConfigValues<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
221
|
+
};
|
|
222
|
+
};
|
|
223
|
+
}): Promise<C_1 & {
|
|
224
|
+
droit: DroitSurLaChose;
|
|
225
|
+
}>;
|
|
226
|
+
chercher<C_1 = import("./partage.ts").ChoseLue>(personne: Personne, arguments_: Record<string, unknown>, { colonnes: liste, condition }?: {
|
|
227
|
+
colonnes?: string;
|
|
228
|
+
condition?: (valeur: (une: unknown) => string) => string;
|
|
229
|
+
}): Promise<{
|
|
230
|
+
lignes: (C_1 & {
|
|
231
|
+
droit: DroitSurLaChose;
|
|
232
|
+
})[];
|
|
233
|
+
total: number;
|
|
234
|
+
}>;
|
|
235
|
+
ouvrirALaCreation(client: {
|
|
236
|
+
query: {
|
|
237
|
+
<T extends import("pg").Submittable>(queryStream: T): T;
|
|
238
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryArrayResult<R>>;
|
|
239
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryConfig: import("pg").QueryConfig<I>): Promise<import("pg").QueryResult<R>>;
|
|
240
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, values?: import("pg").QueryConfigValues<I>): Promise<import("pg").QueryResult<R>>;
|
|
241
|
+
<R extends any[] = any[], I = any[]>(queryConfig: import("pg").QueryArrayConfig<I>, callback: (err: Error, result: import("pg").QueryArrayResult<R>) => void): void;
|
|
242
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryTextOrConfig: string | import("pg").QueryConfig<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
243
|
+
<R extends import("pg").QueryResultRow = any, I = any[]>(queryText: string, values: import("pg").QueryConfigValues<I>, callback: (err: Error, result: import("pg").QueryResult<R>) => void): void;
|
|
244
|
+
};
|
|
245
|
+
}, id: string): Promise<void>;
|
|
246
|
+
partageDe(id: string): Promise<import("./partage.ts").Ouverture[]>;
|
|
247
|
+
partager(personne: Personne, id: string, arguments_: Record<string, unknown>): Promise<import("./partage.ts").Ouverture[]>;
|
|
248
|
+
nePlusPartager(personne: Personne, id: string, arguments_: Record<string, unknown>): Promise<import("./partage.ts").Ouverture[]>;
|
|
249
|
+
donner(personne: Personne, id: string, arguments_: Record<string, unknown>): Promise<{
|
|
250
|
+
id: string;
|
|
251
|
+
proprietaire: {
|
|
252
|
+
nom: string;
|
|
253
|
+
email: string;
|
|
254
|
+
};
|
|
255
|
+
partage: import("./partage.ts").Ouverture[];
|
|
256
|
+
}>;
|
|
257
|
+
donnerLesChoses(personne: Personne, arguments_: Record<string, unknown>): Promise<import("./partage.ts").ChosesDonnees>;
|
|
258
|
+
};
|
|
259
|
+
comptesVisibles: (personne: Personne) => Promise<CompteVisible<C>[]>;
|
|
260
|
+
choisirLeCompte: (personne: Personne, compte: unknown, { droit, aucun }: {
|
|
261
|
+
droit?: DroitSurLaChose;
|
|
262
|
+
aucun: string;
|
|
263
|
+
}) => Promise<CompteVisible<C>>;
|
|
264
|
+
personneDuLien: (id: string) => Promise<Personne | undefined>;
|
|
265
|
+
quiRebranche: (compte: Pick<CompteVisible<C>, 'nom' | 'proprietaire'>, personne: Pick<Personne, 'id'>) => string;
|
|
266
|
+
};
|
|
267
|
+
export type PartageDesComptes<C extends object = Record<string, unknown>> = ReturnType<typeof creerLePartageDesComptes<C>>;
|
package/src/compte.js
CHANGED
|
@@ -1,12 +1,15 @@
|
|
|
1
1
|
import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
|
|
2
2
|
import { Refus } from './mcp.js';
|
|
3
3
|
import { traiterUnGesteDEcran } from './page.js';
|
|
4
|
+
import { creerLePartage, nomDe, suffit } from './partage.js';
|
|
4
5
|
import { creerLaSession } from './session.js';
|
|
5
|
-
// Un compte branché (
|
|
6
|
+
// Un compte branché (indos/bibliotheque/CLAUDE.md, « Un compte branché ») : l'accès d'une
|
|
6
7
|
// personne à un service extérieur, comme une boîte mail, un agenda ou un kDrive. Il vit dans la
|
|
7
8
|
// base de l'app qui s'en sert, son secret chiffré ; la personne le branche, le modifie et le retire
|
|
8
|
-
// dans les réglages de l'app, sur l'écran commun des comptes
|
|
9
|
-
//
|
|
9
|
+
// dans les réglages de l'app, sur l'écran commun des comptes. Il est à elle seule tant qu'elle ne
|
|
10
|
+
// l'ouvre à personne ; elle peut l'ouvrir à des personnes, à des groupes ou à toute l'équipe, en
|
|
11
|
+
// lecture ou en modification, et le donner (`creerLePartageDesComptes`). Claude ne voit jamais son
|
|
12
|
+
// secret.
|
|
10
13
|
// Le secret d'un compte (un mot de passe, un jeton), chiffré en AES-256-GCM par une clé de l'app
|
|
11
14
|
// tirée de `CLE` (`deriver(CLE, <usage>)`) : le vecteur (12 octets), l'étiquette (16) et le
|
|
12
15
|
// chiffré, ensemble en base64. L'identifiant du compte entre dans les données authentifiées : un
|
|
@@ -38,17 +41,21 @@ export function garderLeSecret(cle, compte, chiffre, destination, enregistree) {
|
|
|
38
41
|
}
|
|
39
42
|
return dechiffrer(cle, compte, chiffre);
|
|
40
43
|
}
|
|
44
|
+
// Le nom d'un compte tient en 100 caractères au plus.
|
|
45
|
+
const longueurDuNom = 100;
|
|
46
|
+
// La phrase du formulaire d'un compte ouvert à d'autres.
|
|
47
|
+
const phraseDuCompteOuvert = 'Ce compte est ouvert à d\'autres : ce que vous y branchez leur est ouvert.';
|
|
41
48
|
// Les messages après un geste, par leur code (`?fait=<code>`).
|
|
42
49
|
const faitsParDefaut = {
|
|
43
|
-
branche: { titre: '
|
|
44
|
-
modifie: { titre: '
|
|
45
|
-
retire: { titre: '
|
|
50
|
+
branche: { titre: 'Le compte est branché.' },
|
|
51
|
+
modifie: { titre: 'Les modifications sont enregistrées.' },
|
|
52
|
+
retire: { titre: 'Le compte est retiré.', texte: 'Son accès est effacé de l\'OS.' },
|
|
46
53
|
};
|
|
47
54
|
// Ce qu'entraîne le retrait d'un compte, quand l'app ne le dit pas.
|
|
48
55
|
const suitesParDefaut = ['Son accès est effacé de l\'OS.', 'Rien n\'est effacé chez son fournisseur.'];
|
|
49
56
|
// L'identifiant d'un compte, un UUID.
|
|
50
57
|
const formeDUnId = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
51
|
-
// Les gestes d'écran des comptes d'une app (bibliotheque/CLAUDE.md, « Un compte branché »), que
|
|
58
|
+
// Les gestes d'écran des comptes d'une app (indos/bibliotheque/CLAUDE.md, « Un compte branché »), que
|
|
52
59
|
// l'écran commun des comptes (`EcranDesComptes`, `@indos/bibliotheque/espace`) appelle depuis la page
|
|
53
60
|
// de l'app. Il rend `traiter(requete, reponse, chemin)`, qui sert `/espace/comptes/…` et rend faux
|
|
54
61
|
// pour un autre chemin ; `chemin` est celui de la requête, sans le chemin de l'app. Chaque geste
|
|
@@ -57,14 +64,24 @@ const formeDUnId = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12
|
|
|
57
64
|
// - `lister`, `{}` : les comptes de la personne, sans la valeur d'aucun secret ;
|
|
58
65
|
// - `brancher`, `{ valeurs }` ; `modifier`, `{ id, valeurs }` ; `retirer`, `{ id }` : `{}`, ou le
|
|
59
66
|
// refus de l'app (422), son texte.
|
|
67
|
+
// Avec `partage`, les comptes se partagent : `lister` rend aussi ceux qui sont ouverts à la personne,
|
|
68
|
+
// sans valeurs ni lien, et `partage`, `partager`, `ne-plus-partager`, `donner` (`{ id, … }`) servent
|
|
69
|
+
// le partage du compte, au propriétaire seul ; `modifier` et `retirer` lui sont réservés aussi.
|
|
60
70
|
// Une erreur levée par un geste de l'app, ou un lien d'une autre origine, répond 500, sa cause au
|
|
61
71
|
// journal de l'app.
|
|
62
72
|
export function creerLesGestesDesComptes(options) {
|
|
63
|
-
const { textes, champs } = options;
|
|
73
|
+
const { textes, champs, partage } = options;
|
|
74
|
+
if (partage && champs.some((champ) => champ.nom === 'nom')) {
|
|
75
|
+
throw new Error('Un champ d\'un compte partagé ne prend pas le nom `nom` : le nom du compte est le champ commun.');
|
|
76
|
+
}
|
|
77
|
+
if (textes.etapes?.length && !textes.fournisseur) {
|
|
78
|
+
throw new Error('Des étapes chez le service demandent `textes.fournisseur`, le nom du service.');
|
|
79
|
+
}
|
|
64
80
|
const session = creerLaSession(options.adresse, options.adresseDuCore);
|
|
65
81
|
const racine = options.adresse.replace(/\/$/, '');
|
|
66
82
|
const origine = new URL(racine).origin;
|
|
67
83
|
const secrets = new Set(champs.filter((champ) => champ.genre === 'secret').map((champ) => champ.nom));
|
|
84
|
+
const champsRendus = new Set([...champs.map((champ) => champ.nom), ...(partage ? ['nom'] : [])]);
|
|
68
85
|
function decrire(personne) {
|
|
69
86
|
return {
|
|
70
87
|
titre: textes.titre,
|
|
@@ -73,19 +90,24 @@ export function creerLesGestesDesComptes(options) {
|
|
|
73
90
|
brancher: textes.brancher,
|
|
74
91
|
retirer: textes.retirer,
|
|
75
92
|
etapes: textes.etapes ?? [],
|
|
93
|
+
...(textes.fournisseur ? { fournisseur: textes.fournisseur } : {}),
|
|
94
|
+
...(textes.introduction ? { introduction: textes.introduction } : {}),
|
|
95
|
+
...(textes.note ? { note: textes.note } : {}),
|
|
96
|
+
...(textes.connecter ? { connecter: textes.connecter } : {}),
|
|
76
97
|
suites: textes.suites ?? suitesParDefaut,
|
|
77
98
|
faits: { ...faitsParDefaut, ...textes.faits },
|
|
78
|
-
champs: champs.map(champDecrit),
|
|
99
|
+
champs: [...(partage ? [champDuNom(textes.nom)] : []), ...champs.map(champDecrit)],
|
|
100
|
+
...(partage ? { ...(textes.enEntier !== undefined ? { enEntier: textes.enEntier } : {}), partagePar: phraseDuCompteOuvert } : {}),
|
|
79
101
|
};
|
|
80
102
|
}
|
|
81
|
-
// Un compte de
|
|
82
|
-
// lien rendu entier, qui ne mène qu'à l'app.
|
|
103
|
+
// Un compte de la personne, pour l'écran : ses valeurs sans aucun secret, même si l'app l'y met, et
|
|
104
|
+
// son lien rendu entier, qui ne mène qu'à l'app.
|
|
83
105
|
function compteListe(compte) {
|
|
84
106
|
const valeurs = {};
|
|
85
|
-
for (const
|
|
86
|
-
const valeur = compte.valeurs[
|
|
87
|
-
if (!secrets.has(
|
|
88
|
-
valeurs[
|
|
107
|
+
for (const nom of champsRendus) {
|
|
108
|
+
const valeur = compte.valeurs[nom];
|
|
109
|
+
if (!secrets.has(nom) && typeof valeur === 'string') {
|
|
110
|
+
valeurs[nom] = valeur;
|
|
89
111
|
}
|
|
90
112
|
}
|
|
91
113
|
let lien;
|
|
@@ -105,14 +127,51 @@ export function creerLesGestesDesComptes(options) {
|
|
|
105
127
|
...(lien ? { lien } : {}),
|
|
106
128
|
};
|
|
107
129
|
}
|
|
130
|
+
// Un compte ouvert à la personne par un autre : son nom, son détail, ses états, son droit et qui
|
|
131
|
+
// l'a branché ; ni valeurs, ni lien, quoi que mette l'app.
|
|
132
|
+
function compteOuvert(compte, annuaire) {
|
|
133
|
+
return {
|
|
134
|
+
id: compte.id,
|
|
135
|
+
nom: compte.nom,
|
|
136
|
+
...(compte.detail ? { detail: compte.detail } : {}),
|
|
137
|
+
etats: compte.etats ?? [],
|
|
138
|
+
valeurs: {},
|
|
139
|
+
droit: compte.droit ?? 'lecture',
|
|
140
|
+
donnable: compte.donnable !== false,
|
|
141
|
+
proprietaire: { nom: nomDe(annuaire, compte.proprietaire ?? '') },
|
|
142
|
+
};
|
|
143
|
+
}
|
|
144
|
+
// Les comptes de la personne, puis ceux qui lui sont ouverts ; l'annuaire du core ne se lit que
|
|
145
|
+
// s'il y en a.
|
|
146
|
+
async function comptesListes(personne) {
|
|
147
|
+
const montres = await options.comptesDe(personne);
|
|
148
|
+
if (!partage) {
|
|
149
|
+
return montres.map(compteListe);
|
|
150
|
+
}
|
|
151
|
+
const siens = montres.filter((compte) => (compte.droit ?? 'proprietaire') === 'proprietaire');
|
|
152
|
+
const ouverts = montres.filter((compte) => (compte.droit ?? 'proprietaire') !== 'proprietaire');
|
|
153
|
+
const annuaire = ouverts.length > 0 ? await partage.lireLAnnuaire() : undefined;
|
|
154
|
+
return [
|
|
155
|
+
...siens.map((compte) => ({ ...compteListe(compte), droit: 'proprietaire', donnable: compte.donnable !== false })),
|
|
156
|
+
...ouverts.map((compte) => compteOuvert(compte, annuaire)),
|
|
157
|
+
];
|
|
158
|
+
}
|
|
108
159
|
// Les valeurs envoyées, une par champ : un texte, vide s'il manque ou n'en est pas un ; une case
|
|
109
|
-
// vaut `oui` ou vide. Un nom inconnu est ignoré.
|
|
160
|
+
// vaut `oui` ou vide. Un nom inconnu est ignoré. Avec `partage`, le nom du compte, sans ses espaces.
|
|
110
161
|
function valeursDe(corps) {
|
|
111
162
|
const envoyees = typeof corps.valeurs === 'object' && corps.valeurs !== null ? corps.valeurs : {};
|
|
112
|
-
|
|
163
|
+
const valeurs = Object.fromEntries(champs.map((champ) => {
|
|
113
164
|
const valeur = Object.hasOwn(envoyees, champ.nom) && typeof envoyees[champ.nom] === 'string' ? envoyees[champ.nom] : '';
|
|
114
165
|
return [champ.nom, champ.genre === 'case' ? (valeur === 'oui' ? 'oui' : '') : valeur];
|
|
115
166
|
}));
|
|
167
|
+
if (!partage) {
|
|
168
|
+
return valeurs;
|
|
169
|
+
}
|
|
170
|
+
const nom = typeof envoyees.nom === 'string' ? envoyees.nom.trim() : '';
|
|
171
|
+
if (nom.length > longueurDuNom) {
|
|
172
|
+
throw new Refus(`Le nom d'un compte tient en ${longueurDuNom} caractères au plus.`);
|
|
173
|
+
}
|
|
174
|
+
return { ...valeurs, nom };
|
|
116
175
|
}
|
|
117
176
|
function idDe(corps) {
|
|
118
177
|
if (typeof corps.id !== 'string' || !formeDUnId.test(corps.id)) {
|
|
@@ -120,6 +179,15 @@ export function creerLesGestesDesComptes(options) {
|
|
|
120
179
|
}
|
|
121
180
|
return corps.id;
|
|
122
181
|
}
|
|
182
|
+
// L'identifiant d'un compte à la personne, ou le refus d'un compte absent : un compte qui n'est
|
|
183
|
+
// qu'ouvert à elle, ou qu'elle ne voit pas, répond comme un compte absent.
|
|
184
|
+
async function idDuProprietaire(personne, corps) {
|
|
185
|
+
const id = idDe(corps);
|
|
186
|
+
if (partage && (await partage.droitSur(personne, id)) !== 'proprietaire') {
|
|
187
|
+
throw new Refus('Ce compte n\'existe pas.');
|
|
188
|
+
}
|
|
189
|
+
return id;
|
|
190
|
+
}
|
|
123
191
|
// Ce que l'app rend pour refuser des valeurs devient le refus du geste.
|
|
124
192
|
function refuserSi(erreur) {
|
|
125
193
|
if (erreur) {
|
|
@@ -131,21 +199,63 @@ export function creerLesGestesDesComptes(options) {
|
|
|
131
199
|
return decrire(personne);
|
|
132
200
|
},
|
|
133
201
|
async lister(personne) {
|
|
134
|
-
return { comptes:
|
|
202
|
+
return { comptes: await comptesListes(personne) };
|
|
135
203
|
},
|
|
136
204
|
async brancher(personne, corps) {
|
|
137
|
-
|
|
205
|
+
const rendu = await options.brancher(personne, valeursDe(corps));
|
|
206
|
+
if (typeof rendu === 'object') {
|
|
207
|
+
const cible = new URL(rendu.connexion, `${racine}/`);
|
|
208
|
+
if (cible.origin !== origine) {
|
|
209
|
+
throw new Error(`La connexion d'un compte mène à une page de l'app, pas à ${cible.origin}.`);
|
|
210
|
+
}
|
|
211
|
+
return { connexion: cible.href };
|
|
212
|
+
}
|
|
213
|
+
refuserSi(rendu);
|
|
214
|
+
return {};
|
|
138
215
|
},
|
|
139
216
|
async modifier(personne, corps) {
|
|
140
|
-
const id =
|
|
217
|
+
const id = await idDuProprietaire(personne, corps);
|
|
141
218
|
refuserSi(await options.modifier(personne, id, valeursDe(corps)));
|
|
142
219
|
},
|
|
143
220
|
async retirer(personne, corps) {
|
|
144
|
-
await options.retirer(personne,
|
|
221
|
+
await options.retirer(personne, await idDuProprietaire(personne, corps));
|
|
145
222
|
},
|
|
146
223
|
};
|
|
224
|
+
if (partage) {
|
|
225
|
+
// Les arguments des gestes du partage : ceux des outils `partager` et `ne_plus_partager` d'une
|
|
226
|
+
// chose, sans rien d'autre.
|
|
227
|
+
const cibles = (corps) => ({ personnes: corps.personnes, groupes: corps.groupes, equipe: corps.equipe });
|
|
228
|
+
Object.assign(gestes, {
|
|
229
|
+
async partage(personne, corps) {
|
|
230
|
+
return { ouvertures: await partage.partageDe(await idDuProprietaire(personne, corps)) };
|
|
231
|
+
},
|
|
232
|
+
async partager(personne, corps) {
|
|
233
|
+
const id = await idDuProprietaire(personne, corps);
|
|
234
|
+
return { ouvertures: await partage.partager(personne, id, { ...cibles(corps), droit: corps.droit, confirmer: corps.confirmer }) };
|
|
235
|
+
},
|
|
236
|
+
async 'ne-plus-partager'(personne, corps) {
|
|
237
|
+
const id = await idDuProprietaire(personne, corps);
|
|
238
|
+
return { ouvertures: await partage.nePlusPartager(personne, id, { ...cibles(corps), groupes_supprimes: corps.groupes_supprimes }) };
|
|
239
|
+
},
|
|
240
|
+
async donner(personne, corps) {
|
|
241
|
+
const id = await idDuProprietaire(personne, corps);
|
|
242
|
+
const compte = (await options.comptesDe(personne)).find((un) => un.id === id);
|
|
243
|
+
if (compte?.donnable === false) {
|
|
244
|
+
throw new Refus(textes.sansDon ?? 'Ce compte ne se donne pas.');
|
|
245
|
+
}
|
|
246
|
+
const { proprietaire } = await partage.donner(personne, id, { a: corps.a, confirmer: corps.confirmer });
|
|
247
|
+
try {
|
|
248
|
+
await options.apresUnDon?.(id);
|
|
249
|
+
}
|
|
250
|
+
catch (erreur) {
|
|
251
|
+
console.error(`La relecture après le don de ${id} a échoué :`, erreur);
|
|
252
|
+
}
|
|
253
|
+
return { proprietaire };
|
|
254
|
+
},
|
|
255
|
+
});
|
|
256
|
+
}
|
|
147
257
|
return async function traiter(requete, reponse, chemin) {
|
|
148
|
-
const [, nom] = /^\/espace\/comptes\/([a-z]+)$/.exec(chemin.split('?')[0]) ?? [];
|
|
258
|
+
const [, nom] = /^\/espace\/comptes\/([a-z-]+)$/.exec(chemin.split('?')[0]) ?? [];
|
|
149
259
|
const geste = nom && Object.hasOwn(gestes, nom) ? gestes[nom] : undefined;
|
|
150
260
|
if (!geste) {
|
|
151
261
|
return false;
|
|
@@ -158,6 +268,110 @@ export function creerLesGestesDesComptes(options) {
|
|
|
158
268
|
return true;
|
|
159
269
|
};
|
|
160
270
|
}
|
|
271
|
+
const personneInconnue = 'une personne inconnue';
|
|
272
|
+
export function creerLePartageDesComptes(options) {
|
|
273
|
+
const { base, table, colonnes } = options;
|
|
274
|
+
const donnable = options.donnable ?? 'true';
|
|
275
|
+
const ordre = options.ordre ?? `${table}.nom, ${table}.id`;
|
|
276
|
+
const partage = creerLePartage({
|
|
277
|
+
base,
|
|
278
|
+
chose: table,
|
|
279
|
+
table,
|
|
280
|
+
nom: 'nom',
|
|
281
|
+
laChose: options.laChose,
|
|
282
|
+
absente: options.absente ?? (() => 'Ce compte n\'existe pas.'),
|
|
283
|
+
colonnes,
|
|
284
|
+
ordre,
|
|
285
|
+
adresseDuCore: options.adresseDuCore,
|
|
286
|
+
cleDAppel: options.cleDAppel,
|
|
287
|
+
...(options.app ? { chemin: () => `/${options.app}/reglages` } : {}),
|
|
288
|
+
// Le don au départ ne passe que les comptes ouverts à quelqu'un, et qui se donnent : un compte
|
|
289
|
+
// qu'elle n'a ouvert à personne reste à son nom.
|
|
290
|
+
auDepart: `exists (select 1 from partage where partage.${table} = ${table}.id) and (${donnable})`,
|
|
291
|
+
});
|
|
292
|
+
// Les comptes que la personne voit : les siens, puis ceux qui lui sont ouverts, chacun avec ses
|
|
293
|
+
// colonnes, son droit, s'il se donne et son propriétaire, nommé par l'annuaire du core. L'annuaire
|
|
294
|
+
// ne se lit que pour les comptes ouverts : les siens ne dépendent pas de lui.
|
|
295
|
+
async function comptesVisibles(personne) {
|
|
296
|
+
const { ouverte, droit, valeurs } = partage.pourLaPersonne(personne, { alias: table, depuis: 1 });
|
|
297
|
+
const { rows } = await base.query(`select ${colonnes}, ${table}.proprietaire as proprietaire_du_compte, (${options.detail}) as detail, ${droit} as droit, (${donnable}) as donnable
|
|
298
|
+
from ${table} where ${ouverte} order by (${table}.proprietaire = $1) desc, ${ordre}`, valeurs);
|
|
299
|
+
const annuaire = rows.some((ligne) => ligne.proprietaire_du_compte !== personne.id) ? await partage.lireLAnnuaire() : undefined;
|
|
300
|
+
return rows.map(({ proprietaire_du_compte: deQui, donnable: seDonne, ...ligne }) => {
|
|
301
|
+
const connue = annuaire?.personnes.find((une) => une.id === deQui);
|
|
302
|
+
const proprietaire = deQui === personne.id
|
|
303
|
+
? { id: personne.id, nom: personne.nom, email: personne.email, active: true }
|
|
304
|
+
: connue ? { id: deQui, nom: connue.nom, email: connue.email, active: connue.active } : { id: deQui, nom: personneInconnue, email: '', active: true };
|
|
305
|
+
return { ...ligne, donnable: seDonne === true, proprietaire };
|
|
306
|
+
});
|
|
307
|
+
}
|
|
308
|
+
// Le compte d'un outil : celui de l'identifiant `compte` ; sans lui, le seul compte de la personne,
|
|
309
|
+
// à défaut le seul qui lui est ouvert. `droit` est celui que le geste demande ; `aucun`, le texte de
|
|
310
|
+
// l'app quand la personne ne voit aucun compte. Tout est un refus : aucun compte, plusieurs comptes
|
|
311
|
+
// sans identifiant (le refus nomme les choix), un identifiant qui n'est pas celui d'un compte
|
|
312
|
+
// visible, un droit qui ne suffit pas (le refus dit qui peut l'ouvrir). L'app lit ensuite le secret
|
|
313
|
+
// du compte par son identifiant.
|
|
314
|
+
async function choisirLeCompte(personne, compte, { droit = 'lecture', aucun }) {
|
|
315
|
+
const visibles = await comptesVisibles(personne);
|
|
316
|
+
if (visibles.length === 0) {
|
|
317
|
+
throw new Refus(aucun);
|
|
318
|
+
}
|
|
319
|
+
const liste = visibles.map((un) => `${un.id} « ${un.nom} », ${un.detail} (${un.droit === 'proprietaire' ? 'à elle' : `ouvert en ${un.droit} par ${un.proprietaire.nom}`})`).join(' ; ');
|
|
320
|
+
let voulu;
|
|
321
|
+
if (compte !== undefined && compte !== null) {
|
|
322
|
+
voulu = visibles.find((un) => un.id === compte);
|
|
323
|
+
if (!voulu) {
|
|
324
|
+
throw new Refus(`Ce compte n'existe pas pour la personne : préciser \`compte\` parmi : ${liste}.`);
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
else {
|
|
328
|
+
const siens = visibles.filter((un) => un.droit === 'proprietaire');
|
|
329
|
+
voulu = siens.length === 1 ? siens[0] : siens.length === 0 && visibles.length === 1 ? visibles[0] : undefined;
|
|
330
|
+
if (!voulu) {
|
|
331
|
+
throw new Refus(`Préciser \`compte\` parmi : ${liste}.`);
|
|
332
|
+
}
|
|
333
|
+
}
|
|
334
|
+
if (!suffit(voulu.droit, droit)) {
|
|
335
|
+
const qui = voulu.proprietaire.email ? `${voulu.proprietaire.nom} (${voulu.proprietaire.email})` : voulu.proprietaire.nom;
|
|
336
|
+
const attendu = droit === 'proprietaire'
|
|
337
|
+
? `ce geste est réservé à ${voulu.proprietaire.nom}, qui l'a branché`
|
|
338
|
+
: `ce geste demande ${droit === 'modification' ? 'la modification' : 'la lecture'}, que la personne qui a branché le compte, ${voulu.proprietaire.nom}, peut lui ouvrir dans les réglages de l'app`;
|
|
339
|
+
throw new Refus(`« ${voulu.nom} » est ouvert à la personne en ${voulu.droit} par ${qui} : ${attendu}.`);
|
|
340
|
+
}
|
|
341
|
+
return voulu;
|
|
342
|
+
}
|
|
343
|
+
// La personne d'un lien signé, relue à l'annuaire du core sans cache, avec ses groupes : rien pour
|
|
344
|
+
// une personne inconnue ou désactivée. Un core qui ne répond pas lève une erreur : le lien est refusé.
|
|
345
|
+
async function personneDuLien(id) {
|
|
346
|
+
const annuaire = await partage.lireLAnnuaire({ sansCache: true });
|
|
347
|
+
const connue = annuaire.personnes.find((une) => une.id === id);
|
|
348
|
+
if (!connue?.active) {
|
|
349
|
+
return undefined;
|
|
350
|
+
}
|
|
351
|
+
return {
|
|
352
|
+
id: connue.id,
|
|
353
|
+
email: connue.email,
|
|
354
|
+
nom: connue.nom,
|
|
355
|
+
proprietaire: connue.proprietaire === true,
|
|
356
|
+
groupes: annuaire.groupes.filter((groupe) => groupe.membres.includes(id)).map((groupe) => groupe.id),
|
|
357
|
+
};
|
|
358
|
+
}
|
|
359
|
+
// Qui rebranche un compte dont l'accès ne s'ouvre plus, pour une phrase « <qui> le remplace dans
|
|
360
|
+
// les réglages » : « la personne » pour un compte à elle, « <nom> (<courriel>), qui l'a branché, »
|
|
361
|
+
// pour un compte ouvert. Pour un propriétaire désactivé (`proprietaire.active` faux), une phrase
|
|
362
|
+
// entière, que l'app rend telle quelle : le compte reste à son nom jusqu'au don.
|
|
363
|
+
function quiRebranche(compte, personne) {
|
|
364
|
+
const { proprietaire } = compte;
|
|
365
|
+
if (proprietaire.id === personne.id) {
|
|
366
|
+
return 'la personne';
|
|
367
|
+
}
|
|
368
|
+
if (!proprietaire.active) {
|
|
369
|
+
return `« ${compte.nom} » est à ${proprietaire.nom}, qui n'est plus dans l'équipe : il reste à son nom jusqu'à ce que le propriétaire de l'OS donne ses choses ; qui en a besoin d'ici là branche son propre compte et le partage.`;
|
|
370
|
+
}
|
|
371
|
+
return `${proprietaire.nom}${proprietaire.email ? ` (${proprietaire.email})` : ''}, qui l'a branché,`;
|
|
372
|
+
}
|
|
373
|
+
return { ...partage, partage, comptesVisibles, choisirLeCompte, personneDuLien, quiRebranche };
|
|
374
|
+
}
|
|
161
375
|
// Un champ, tel que `decrire` le rend.
|
|
162
376
|
function champDecrit(champ) {
|
|
163
377
|
const genre = champ.genre ?? 'texte';
|
|
@@ -174,3 +388,17 @@ function champDecrit(champ) {
|
|
|
174
388
|
...(champ.groupe !== undefined ? { groupe: champ.groupe } : {}),
|
|
175
389
|
};
|
|
176
390
|
}
|
|
391
|
+
// Le champ « Nom » d'un compte partagé : en tête du formulaire, facultatif ; l'app donne son exemple
|
|
392
|
+
// et son aide, et pose son nom par défaut quand il est vide.
|
|
393
|
+
function champDuNom(textes = {}) {
|
|
394
|
+
return {
|
|
395
|
+
nom: 'nom',
|
|
396
|
+
libelle: 'Nom',
|
|
397
|
+
genre: 'texte',
|
|
398
|
+
requis: false,
|
|
399
|
+
avecLeSuivant: false,
|
|
400
|
+
fixe: false,
|
|
401
|
+
...(textes.exemple !== undefined ? { exemple: textes.exemple } : {}),
|
|
402
|
+
...(textes.aide !== undefined ? { aide: textes.aide } : {}),
|
|
403
|
+
};
|
|
404
|
+
}
|