fs-words.git

1) #!/usr/bin/env node
2) 
3) /*
4) import {repositories.language} from './repository-language';
5) import {repositories.type} from './repository-type';
6) import {repositories.tag} from './repository-tag';
7) import {repositories.concept} from './repository-concept';
8)  */
9) 
10) 

11) function syntaxerror() : void
12) {
13) 	console.error("-- wrong syntax");
14) 	process.exit(1);
15) }
16) 
17) 

18) /**
19)  */
20) async function main(args : Array<string>) : Promise<void>
21) {
22) 	const command : string = args.shift();
23) 	switch (command)
24) 	{
25) 		case "setup":
26) 		{

27) 			await repositories.language.setup();
28) 			await repositories.type.setup();
29) 			await repositories.tag.setup();
30) 			await repositories.expression.setup();
31) 			await repositories.concept.setup();

32) 			process.exit(0);
33) 			break;
34) 		}

35) 		case "show":

36) 		{

37) 			const concept_id = parseInt(args.shift());

38) 			const exposal : services.concept.type_exposal = await services.concept.expose(concept_id);

39) 			console.info(helpers.json.encode_extended(exposal, true, 0));

40) 			process.exit(0);
41) 			break;
42) 		}
43) 		case "translate":
44) 		{
45) 			const language_from : string = args.shift();
46) 			const language_to : string = args.shift();

47) 			const part : string = args.join(" "); args = [];

48) 			const result = await services.concept.get_translations
49) 			(
50) 				language_from,
51) 				language_to,
52) 				part
53) 			);
54) 			result.forEach
55) 			(
56) 				(entry) =>
57) 				{
58) 					console.info
59) 					(
60) 						helpers.string.coin
61) 						(
62) 							"[{{language_from}}] {{value_from}} ~ [{{language_to}}] {{value_to}}",
63) 							{

64) 								"language_from": entry["language_from"],

65) 								"value_from": entry["value_from"],

66) 								"language_to": entry["language_to"],

67) 								"value_to": entry["value_to"],
68) 							}
69) 						)
70) 					);
71) 				}
72) 			);
73) 			process.exit(0);
74) 			break;
75) 		}
76) 		case "export":
77) 		{

78) 			const directory : string = ((args.length >= 1) ? args.shift() : "/tmp");
79) 			const result : Array<services.concept.type_exposal> = await services.concept.export_();

80) 			const digits : int = 3;
81) 			for (const exposal of result)

82) 			{
83) 				const path : string = helpers.string.coin
84) 				(
85) 					"{{directory}}/concept_{{id}}.json",
86) 					{
87) 						"directory": directory,

88) 						"id": helpers.string.pad_left(exposal.id.toFixed(0), digits, "0"),

89) 					}
90) 				);

91) 				delete exposal.id;
92) 				const content : string = helpers.json.encode_extended(exposal, true, 0);

93) 				await helpers.file.write(path, content);

94) 				// console.info(path);

95) 			}
96) 			console.info(directory);

97) 			process.exit(0);
98) 			break;
99) 		}

100) 		case "search":

101) 		{

102) 			const part : string = args.join(" "); args = [];

103) 			const result : Array<services.concept.type_exposal> = await services.concept.search(part);

104) 			result.forEach
105) 			(
106) 				(entry) =>
107) 				{
108) 					console.info
109) 					(
110) 						helpers.string.coin
111) 						(

112) 							"{{id}} | {{type}} | {{description}} | {{tags}} | {{expressions}}",

113) 							{
114) 								"id": entry["id"].toFixed(),
115) 								"type": entry["type"],
116) 								"description": (entry["description"] ?? '-'),
117) 								"tags": entry["tags"].join(","),

118) 								"expressions": (
119) 									() =>
120) 									{
121) 										let parts : Array<string> = [];
122) 										for (const [key, value] of Object.entries(entry["expressions"]))
123) 										{
124) 											parts.push(key + ":" + value.join("/"));
125) 										}
126) 										return parts.join(",");
127) 									}
128) 								) (),

129) 							}
130) 						)
131) 					);
132) 				}
133) 			);
134) 			process.exit(0);
135) 			break;
136) 		}
137) 		case "feed":
138) 		{
139) 			const content : string = await helpers.misc.stdin();
140) 			const data : any = JSON.parse(content);
141) 			const concept_thing : any = data;
142) 			const concept_id : int = await services.concept.suck(concept_thing);
143) 			console.info(concept_id);
144) 			process.exit(0);

145) 			break;
146) 		}

147) 		case "new":
148) 		{
149) 			if (args.length < 1)
150) 			{
151) 				syntaxerror();
152) 			}
153) 			else
154) 			{
155) 				const type : string = args.shift();
156) 				const tags : Array<string> = (
157) 					(args.length >= 1)
158) 					? args.shift().split(",")
159) 					: []
160) 				);
161) 				const description : string = (
162) 					(args.length >= 1)
163) 					? args.shift()
164) 					: null
165) 				);
166) 				const concept_thing : any =
167) 				{
168) 					"type": type,
169) 					"description": description,
170) 					"tags": tags,

171) 					"expressions": [],

172) 				};
173) 				const concept_id : int = await services.concept.suck(concept_thing);
174) 				console.info(concept_id);
175) 				process.exit(0);
176) 			}
177) 			break;
178) 		}
179) 		case "set":
180) 		{
181) 			if (args.length < 1)
182) 			{
183) 				syntaxerror();
184) 			}
185) 			else
186) 			{
187) 				const concept_id : int = parseInt(args.shift());
188) 			}
189) 		}

190) 		default:
191) 		{
192) 			console.error("unhandled command: " + command);
193) 			process.exit(1);
194) 			break;
195) 		}
196) 	}
197) }
198) 
199) 

200) main(process.argv.slice(2))
201) .catch
202) (
203) 	(error) =>
204) 	{
205) 		console.error(error.toString());
206) 	}
207) );