fs-words.git

1) namespace repositories
2) {
3) 	

4) 	export var concept_core : helpers.repository_sqltable =
5) 	{
6) 		"setup": function ()
7) 		{
8) 			return helpers.database.query_do_named("concept.setup-core");
9) 		},
10) 		"teardown": function ()
11) 		{
12) 			throw (new Error("not implemented"));
13) 		},
14) 		"create": function (row)
15) 		{
16) 			return helpers.database.query_put_free
17) 			(
18) 				"INSERT INTO concepts(type_id, description) VALUES (:type_id, :description);",
19) 				{
20) 					"type_id": row["type_id"],
21) 					"description": row["description"],
22) 				}
23) 			);
24) 		},
25) 		"update": function (concept_id, row)
26) 		{
27) 			return helpers.database.query_do_free
28) 			(
29) 				"UPDATE concepts SET type_id = :type_id, description = :description WHERE (id = :id)",
30) 				{
31) 					"id": concept_id,
32) 					"type_id": row["type_id"],
33) 					"description": row["description"],
34) 				}
35) 			);
36) 		},
37) 		"delete": function (concept_id)
38) 		{
39) 			return helpers.database.query_do_free
40) 			(
41) 				"DELETE FROM concepts WHERE (id = :id)",
42) 				{
43) 					"id": concept_id,
44) 				}
45) 			);
46) 		},
47) 		"read": function (concept_id)
48) 		{
49) 			return (
50) 				helpers.database.query_get_free
51) 				(
52) 					"SELECT type_id,description FROM concepts WHERE (id = :id)",
53) 					{
54) 						"id": concept_id,
55) 					}
56) 				)
57) 				.then
58) 				(
59) 					(rows) => (
60) 						(rows.length === 1)
61) 						? Promise.resolve<type_row>(rows[0])
62) 						: Promise.reject<type_row>(new Error("not found"))
63) 					)
64) 				)
65) 			);
66) 		},
67) 		"purge": async function (column, value)
68) 		{
69) 			throw (new Error("not implemented"));
70) 		},
71) 		"take": async function (column, value)
72) 		{
73) 			throw (new Error("not implemented"));
74) 		},
75) 	};
76) 	
77) 	
78) 	export var concept_tags : helpers.repository_sqltable =
79) 	{
80) 		"setup": function ()
81) 		{
82) 			return helpers.database.query_do_named("concept.setup-tags");
83) 		},
84) 		"teardown": function ()
85) 		{
86) 			throw (new Error("not implemented"));
87) 		},
88) 		"create": function (row)
89) 		{
90) 			return helpers.database.query_put_free
91) 			(
92) 				"INSERT INTO concept_tags(concept_id, tag_id) VALUES (:concept_id, :tag_id);",
93) 				{
94) 					"concept_id": row["concept_id"],
95) 					"tag_id": row["tag_id"],
96) 				}
97) 			);
98) 		},
99) 		"update": function (concept_tag_id, row)
100) 		{
101) 			return helpers.database.query_do_free
102) 			(
103) 				"UPDATE concept_tags SET concept_id = :concept_id, tag_id = :tag_id WHERE (id = :id)",
104) 				{
105) 					"id": concept_tag_id,
106) 					"concept_id": row["concept_id"],
107) 					"tag_id": row["tag_id"],
108) 				}
109) 			);
110) 		},
111) 		"delete": function (concept_tag_id)
112) 		{
113) 			return helpers.database.query_do_free
114) 			(
115) 				"DELETE FROM concept_tags WHERE (id = :id)",
116) 				{
117) 					"id": concept_tag_id,
118) 				}
119) 			);
120) 		},
121) 		"read": async function (concept_tag_id)
122) 		{
123) 			return (
124) 				helpers.database.query_get_free
125) 				(
126) 					"SELECT concept_id,tag_id FROM concept_tags WHERE (id = :id)",
127) 					{
128) 						"id": concept_tag_id,
129) 					}
130) 				)
131) 				.then
132) 				(
133) 					(rows) => (
134) 						(rows.length === 1)
135) 						? Promise.resolve<type_row>(rows[0])
136) 						: Promise.reject<type_row>(new Error("not found"))
137) 					)
138) 				)
139) 			);
140) 		},
141) 		"purge": async function (column, value)
142) 		{
143) 			return helpers.database.query_do_free
144) 			(
145) 				"DELETE FROM concept_tags WHERE (" + column + " = :value)",
146) 				{
147) 					"value": value,
148) 				}
149) 			);
150) 		},
151) 		"take": async function (column, value)
152) 		{
153) 			return await helpers.database.query_get_free
154) 			(
155) 				"SELECT concept_id,tag_id FROM concept_tags WHERE (" + column + " = :value)",
156) 				{
157) 					"value": value,
158) 				}
159) 			);
160) 		},
161) 	};
162) 	
163) 	

164) 	/**
165) 	 */

166) 	export var concept_expressions : helpers.repository_sqltable =
167) 	{
168) 		"setup": function ()
169) 		{
170) 			return helpers.database.query_do_named("concept.setup-expressions");
171) 		},
172) 		"teardown": function ()
173) 		{
174) 			throw (new Error("not implemented"));
175) 		},
176) 		"create": function (row)
177) 		{
178) 			return helpers.database.query_put_free
179) 			(
180) 				"INSERT INTO concept_expressions(concept_id, expression_id) VALUES (:concept_id, :expression_id);",
181) 				{
182) 					"concept_id": row["concept_id"],
183) 					"expression_id": row["expression_id"],
184) 				}
185) 			);
186) 		},
187) 		"update": function (concept_expression_id, row)
188) 		{
189) 			return helpers.database.query_do_free
190) 			(
191) 				"UPDATE concept_expressions SET concept_id = :concept_id, expression_id = :expression_id WHERE (id = :id)",
192) 				{
193) 					"id": concept_expression_id,
194) 					"concept_id": row["concept_id"],
195) 					"expression_id": row["expression_id"],
196) 				}
197) 			);
198) 		},
199) 		"delete": function (concept_expression_id)
200) 		{
201) 			return helpers.database.query_do_free
202) 			(
203) 				"DELETE FROM concept_expressions WHERE (id = :id)",
204) 				{
205) 					"id": concept_expression_id,
206) 				}
207) 			);
208) 		},
209) 		"read": async function (concept_expression_id)
210) 		{
211) 			return (
212) 				helpers.database.query_get_free
213) 				(
214) 					"SELECT concept_id,expression_id FROM concept_expressions WHERE (id = :id)",
215) 					{
216) 						"id": concept_expression_id,
217) 					}
218) 				)
219) 				.then
220) 				(
221) 					(rows) => (
222) 						(rows.length === 1)
223) 						? Promise.resolve<type_row>(rows[0])
224) 						: Promise.reject<type_row>(new Error("not found"))
225) 					)
226) 				)
227) 			);
228) 		},
229) 		"purge": async function (column, value)
230) 		{
231) 			return helpers.database.query_do_free
232) 			(
233) 				"DELETE FROM concept_expressions WHERE (" + column + " = :value)",
234) 				{
235) 					"value": value,
236) 				}
237) 			);
238) 		},
239) 		"take": async function (column, value)
240) 		{
241) 			return await helpers.database.query_get_free
242) 			(
243) 				"SELECT concept_id,expression_id FROM concept_expressions WHERE (" + column + " = :value)",
244) 				{
245) 					"value": value,
246) 				}
247) 			);
248) 		},
249) 	};
250) 	
251) 	

252) 	export var concept : (
253) 		helpers.repository<int, entities.concept>
254) 		&
255) 		{
256) 			get_translations : (language_from : string, language_to : string, part : string)=>Promise<Array<type_row>>;

257) 			search : (part : string)=>Promise<Array<int>>;

258) 			export : ()=>Promise<Array<type_row>>;
259) 		}
260) 	) =
261) 	{
262) 		"setup": async function ()
263) 		{

264) 			await concept_core.setup();
265) 			await concept_tags.setup();
266) 			await concept_expressions.setup();

267) 			return Promise.resolve<void>(undefined);
268) 		},
269) 		"teardown": async function ()
270) 		{

271) 			await concept_expressions.teardown();
272) 			await concept_tags.teardown();
273) 			await concept_core.teardown();

274) 			return Promise.resolve<void>(undefined);
275) 		},
276) 		"create": async function (concept_entity)
277) 		{
278) 			const row_core : type_row = {"type_id": concept_entity.type_id, "description": concept_entity.description};

279) 			const concept_id : int = await concept_core.create(row_core);

280) 			for await (let tag_id of concept_entity.tags)
281) 			{
282) 				const row_tag : type_row = {"concept_id": concept_id, "tag_id": tag_id};

283) 				const concept_tag_id : int = await concept_tags.create(row_tag);

284) 			}

285) 			for await (let expression_id of concept_entity.expressions)

286) 			{

287) 				const row_expressions : type_row = {"concept_id": concept_id, "expression_id": expression_id};
288) 				const concept_expressions_id : int = await concept_expressions.create(row_expressions);

289) 			}
290) 			return Promise.resolve<int>(concept_id);
291) 		},
292) 		"update": function (concept_id, concept_entity)
293) 		{
294) 			throw (new Error("not implemented"));
295) 		},
296) 		"delete": async function (concept_id)
297) 		{

298) 			await concept_expressions.purge("concept_id", concept_id);
299) 			await concept_tags.purge("concept_id", concept_id);
300) 			await concept_core.delete(concept_id);

301) 			return Promise.resolve<void>(undefined);
302) 		},
303) 		"read": async function (concept_id)
304) 		{

305) 			const row_core : type_row = await concept_core.read(concept_id);;
306) 			const rows_tags : Array<type_row> = await concept_tags.take("concept_id", concept_id);
307) 			const rows_expressions : Array<type_row> = await concept_expressions.take("concept_id", concept_id);

308) 			const concept_entity : entities.concept =
309) 			{
310) 				"type_id": row_core["type_id"],
311) 				"description": row_core["description"],
312) 				"tags": rows_tags.map(row_tag => row_tag["tag_id"]),

313) 				"expressions": rows_expressions.map(row_expression => row_expression["expression_id"]),

314) 			};
315) 			return Promise.resolve<entities.concept>(concept_entity);
316) 		},

317) 		"get_translations": function (language_from, language_to, part)

318) 		{
319) 			return helpers.database.query_get_named
320) 			(
321) 				"concept.get_translations",
322) 				{

323) 					"language_from": language_from,
324) 					"language_to": language_to,

325) 					"part": part.replace(new RegExp("-", "g"), "%"),
326) 				}
327) 			);
328) 		},

329) 		"search": function (part) : Promise<Array<int>>

330) 		{

331) 			return (
332) 				helpers.database.query_get_named("concept.search", {"part": part.replace(new RegExp("-", "g"), "%")})
333) 				.then<Array<int>>
334) 				(
335) 					(rows) => Promise.resolve<Array<int>>(rows.map(row => row["id"]))
336) 				)
337) 			);

338) 		},

339) 		"export": function () : Promise<Array<type_row>>

340) 		{

341) 			return helpers.database.query_get_named("concept.dump", {"part": null});