· 6 years ago · Mar 11, 2020, 03:12 PM
1let commonDepsDir= __dirname+'/../../../../src/';
2var ErrorManager = require(commonDepsDir+'ErrorManager/ErrorManager.js');
3const func = require(commonDepsDir+"func.js");
4let Security = require(commonDepsDir+"Security/Security.js");
5
6let API = require('../../Api/Api.js');
7let IOAuth = require('../IOAuth/IOAuth.js');
8let SOCKET = require('../SocketServer');
9let CONSOLE = SOCKET.CONSOLE;
10
11var Krypt = require('../../Krypt/Krypt.js');
12let SocketManager = require('../SocketManager.js');
13let PipesManager = require('../../Pipes/PipesManager.js');
14var ClientPipeEvent = require('../../../../../combined/model.pipe.event.js');
15
16const NAMESPACE = "/Pipes";
17
18module.exports = function(IO) {
19
20 let namespace = IO.of(NAMESPACE);
21
22 namespace.on('connection', (socket) => {
23
24
25 sconsole(socket,`Joining namespace... `)
26
27 let h = socket.handshake,
28 token=h.query.id_cloud || null;
29
30 socketCloudID = Krypt.SECURITY.EXTERNAL.DECODE(Krypt.TYPES_EXTERNAL.SOCKETIO,token);
31
32
33 socketCloudID= socketCloudID.id_cloud || false;
34
35 if (!socketCloudID) {
36 sconsole(socket,`Namespace can't be joined.`)
37 socket.emit(PIPES.AUTHENTICATION_FAILED,true);
38 }
39 else
40 {
41 var Socket = SocketManager.retrieve(NAMESPACE,socketCloudID);
42
43 if (!Socket || Socket.getCloudID() !== socketCloudID) {
44 sconsole(socket,`Namespace can't be joined.`)
45 socket.emit(PIPES.AUTHENTICATION_FAILED,true);
46 }
47 else
48 {
49 /*********************************
50 ************** CONNEXION *********
51 *********************************/
52
53 sconsole(socket,`Namespace joined.`)
54 Socket.addNamespace(NAMESPACE,socket);
55 Socket.on(NAMESPACE,'disconnect',() => {
56 SocketManager.emit_to(
57 [NAMESPACE],
58 SocketManager.receiver.contacts,
59 Socket.getProfile().getContacts(),
60 PIPES.CONTACT_DISCONNECTED,
61 Socket.getProfile().getKey()
62 )
63 SocketManager.remove(Socket);
64 })
65
66 Socket.emit([NAMESPACE],PIPES.AUTHENTICATION_GRANTED,true);
67
68 SocketManager.emit_to(
69 [NAMESPACE],
70 SocketManager.receiver.contacts,
71 Socket.getProfile().getContacts(),
72 PIPES.CONTACT_CONNECTED,
73 Socket.getProfile().getKey()
74 )
75
76 SocketManager.join(NAMESPACE,Socket,Socket.getProfile().getPipes())
77
78
79 /*********************************
80 ************** ACTIONS *********
81 *********************************/
82
83
84 /*********************************
85 ************** PIPE_SEND *********
86 *********************************/
87
88 Socket.on(NAMESPACE,PIPES.SEND_MESSAGE,function(data,callback){
89
90 let security = Security.flood_register('socket_send_message',[Socket.getCloudID()],{count:10,time:4,time_cumulation:true});
91 if (!security) {
92 let SystemResponseEvent = PipesManager.createEventSystem(null,ClientPipeEvent.constant.data.pipe_flood);
93 Socket.emit([NAMESPACE], PIPES.RECEIVE_MESSAGE, {target: data.target, event: SystemResponseEvent.toObject()})
94 callback(false);
95 return
96 }
97
98 let room = SocketManager.get_room(NAMESPACE,data.target||null);
99
100 if (!room|| room.indexOf(Socket.getCloudID()) === -1) {
101 ErrorManager.catch(Socket.getMachine(),'PIPES::SEND_EVENT:: Socket trying sending on forbidden pipe key',true);
102 let PipeEvent = new ClientPipeEvent.object(data.event);
103 PipeEvent.setStatus(ClientPipeEvent.constant.status.error);
104 callback(PipeEvent.toObject());
105 }
106 else {
107 PipesManager.get_byKey(data.target).then((Pipe) => {
108
109 if (!Pipe.isBlocked()) {
110
111 let PipeEvent = new ClientPipeEvent.object(data.event)
112 if (!PipeEvent.getKey()) { PipeEvent.setKey(func.randomToken(48)) }
113 PipeEvent.setTarget(Pipe.getKey())
114 PipeEvent.setOrigin(ClientPipeEvent.constant.origin.client);
115 PipeEvent.setOriginKey(Socket.getKeyProfile())
116 PipeEvent.setEncryptLevel(PipeEvent.getSecurity());
117 PipeEvent.setStatus(ClientPipeEvent.constant.status.messagerie);
118 Pipe.addEvent(PipeEvent);
119 if (room.length>1){
120 PipeEvent.setStatus(ClientPipeEvent.constant.status.receiving);
121
122 Socket.broadcast([NAMESPACE,Pipe.getKey()],PIPES.RECEIVE_MESSAGE,{target: Pipe.getKey(), event: PipeEvent.toObject(), unview: Pipe.getUnview()});
123 }else {
124
125 }
126
127 callback(PipeEvent.toObject())
128 Pipe.updateEvent(PipeEvent);
129 }
130
131
132 else {
133
134 let SystemResponseEvent = PipesManager.createEventSystem(Pipe,ClientPipeEvent.constant.data.pipe_blocked);
135 Socket.emit([NAMESPACE], PIPES.RECEIVE_MESSAGE, {target: Pipe.getKey(), event: SystemResponseEvent.toObject(), unview: Pipe.getUnview()})
136 callback(false);
137 /* SI LE PIPE EST BLOCKED */
138 }
139 })
140 }
141 })
142
143
144 /***************************************
145 ************** PIPE_GET_EVENTS *********
146 ***************************************/
147
148 Socket.on(NAMESPACE,PIPES.GET_EVENTS,function(request,callback){
149 let response={}, wait=[];
150
151 for (let [key,pipe] of Object.entries(request)) {
152
153 let room = SocketManager.get_room(NAMESPACE,key) || false;
154 if (room && room.indexOf(Socket.getCloudID()) > -1) {
155 if (!response[key]) { response[key]={}}
156 if (!response[key].events) { response[key].events = []}
157
158 wait.push(
159 new Promise((resolve,reject) => {
160 PipesManager.get_byKey(key)
161 .then((Pipe) => {
162 if (Pipe) {
163 response[key].events = Pipe.getEvents(pipe.limit, pipe.events_id)
164 response[key].synchronize = (pipe.limit!==false&&pipe.limit!==undefined)?pipe.limit:false;
165 response[key].unview = Pipe.getUnview()
166 resolve();
167 }
168 })
169 })
170 )
171 }
172 }
173 Promise.all(wait).then(() => {
174 callback(response);
175 })
176 })
177
178
179 /***************************************
180 ************** PIPE_INPUT_TYPING *********
181 ***************************************/
182
183 Socket.on(NAMESPACE,PIPES.INPUT_TYPING,function(key){
184
185 let room = SocketManager.get_room(NAMESPACE,key) || false;
186 if (room && room.indexOf(Socket.getCloudID()) > -1) {
187 Socket.broadcast([NAMESPACE,key],PIPES.INPUT_TYPING,key)
188 }
189 })
190
191
192 /*********************************
193 ************** EVENTS_RECEIVED *********
194 *********************************/
195
196
197 Socket.on(NAMESPACE,PIPES.EVENTS_RECEIVED,function(events){
198
199 try {
200 let pipes=[];
201 events.map((e) => { if (!pipes[e.target]){pipes[e.target]=[]} pipes[e.target].push(e)})
202 let wait=[];
203 for (let key in pipes) {
204 let room = SocketManager.get_room(NAMESPACE,key) || false;
205 if (room && room.indexOf(Socket.getCloudID()) > -1) {
206 let pipe = pipes[key];
207 PipesManager.get_byKey(key).then((Pipe) => {
208 for (let event of pipe) {
209 event = Pipe.setEventReceived(event)
210 }
211 if (room.length>1){
212 Socket.broadcast([NAMESPACE,Pipe.getKey()], PIPES.EVENTS_RECEIVED, {key: Pipe.getKey(), events: pipe, unview: Pipe.getUnview()});
213 }
214 Pipe.save()
215 })
216 }
217 else {
218 ErrorManager.catch(Socket.getMachine(),'Trying something bad with events received pipes function',true);
219 }
220 }
221 }
222 catch(error) {
223 ErrorManager.catch(Socket.getMachine(),error,true);
224 }
225 })
226
227
228
229 /*********************************
230 ************** EVENTS_VIEWED *********
231 *********************************/
232
233
234
235 Socket.on(NAMESPACE,PIPES.EVENTS_VIEWED,function(events){
236 try {
237 let pipes=[];
238 events.map((e) => { if (!pipes[e.target]){pipes[e.target]=[]} pipes[e.target].push(e)})
239 let wait=[];
240 for (let key in pipes) {
241 let room = SocketManager.get_room(NAMESPACE,key) || false;
242
243 if (room && room.indexOf(Socket.getCloudID()) > -1) {
244
245 let pipe = pipes[key];
246 PipesManager.get_byKey(key).then((Pipe) => {
247 for (let event of pipe) {
248 event = Pipe.setEventViewed(event)
249 }
250 if (room.length>1){
251 Socket.broadcast([NAMESPACE,Pipe.getKey()], PIPES.EVENTS_VIEWED, {key: Pipe.getKey(), events: pipe, unview: Pipe.getUnview()});
252 }
253 Pipe.save()
254 })
255 }
256 else {
257 ErrorManager.catch(Socket.getMachine(),'Trying something bad with events viewed pipes function',true);
258 }
259 }
260 }
261 catch(error) {
262 ErrorManager.catch(Socket.getMachine(),error,true);
263 }
264 })
265
266
267 /*********************************
268 ************** PIPES_GET_OPTIONS *********
269 *********************************/
270
271 Socket.on(NAMESPACE,PIPES.PIPES_GET_OPTIONS,function(pipeskeys,callback){
272
273
274 try {
275 let wait=[], response={};
276 for(let i in pipeskeys) {
277 let key = pipeskeys[i];
278 let room = SocketManager.get_room(NAMESPACE,key) || false;
279 if (room && room.indexOf(Socket.getCloudID()) > -1) {
280 wait.push(
281 new Promise((resolve,reject) => {
282 PipesManager.get_byKey(key).then((Pipe) => {
283 if (Pipe) {
284
285 let m = Socket.getMachine()
286 let SystemResponseEvent = PipesManager.createEventSystem(Pipe,ClientPipeEvent.constant.data.pipe_options_retrieved, Socket.getProfile(),
287 {
288 userAgent: m.userAgent,
289 mobile: m.mobile,
290 version: m.version,
291 os: m.os
292 }
293 );
294
295 Pipe.addEvent(SystemResponseEvent);
296 Socket.broadcast([NAMESPACE,Pipe.getKey()],PIPES.RECEIVE_MESSAGE,{target: Pipe.getKey(), event: SystemResponseEvent.toObject(), unview: Pipe.getUnview()});
297
298 Pipe = Pipe.toJsonData(true);
299 response[Pipe.key] = Pipe;
300 resolve();
301 }
302 else resolve()
303 })
304 })
305
306 )
307 }
308 else {
309 ErrorManager.catch(Socket.getMachine(),'Socket trying gettings options of forbidden pipe',true);
310 }
311 }
312 Promise.all(wait).then(() => {
313 callback(response);
314 })
315 }
316 catch(error) {
317 ErrorManager.catch(Socket.getMachine(),error,true);
318 callback(false)
319 }
320 })
321
322
323 /***********************************************
324 ************** PIPE_REINITIALISATION *********
325 *********************************************/
326
327 Socket.on(NAMESPACE,PIPES.PIPE_REINITIALISATION,function(key,callback){
328
329 try {
330 let room = SocketManager.get_room(NAMESPACE,key) || false;
331 if (room && room.indexOf(Socket.getCloudID()) > -1) {
332 PipesManager.get_byKey(key).then((Pipe) => {
333 Pipe.startReinitialisation(Socket.getProfile()).then(([pipeJSON, status]) => {
334
335 if (pipeJSON&&status) {
336 let event;
337 if (status===1) {
338 event = PipesManager.createEventSystem(Pipe,ClientPipeEvent.constant.data.pipe_reinit, Socket.getProfile())
339 }
340 else if (status===2) {
341 event= PipesManager.createEventSystem(Pipe,ClientPipeEvent.constant.data.pipe_new)
342 }
343 Pipe.addEvent(event);
344
345 SocketManager.emit_to(
346 [NAMESPACE,pipeJSON.key],
347 null,
348 null,
349 PIPES.UPDATE,
350 pipeJSON
351 )
352 SocketManager.emit_to(
353 [NAMESPACE,pipeJSON.key],
354 null,
355 null,
356 PIPES.RECEIVE_MESSAGE,
357 {target: pipeJSON.key, event: event.toObject(), unview: pipeJSON.unview}
358 )
359 callback(true)
360 }
361 else {
362 callback(false);
363 }
364 })
365 })
366
367 }
368 else {
369 ErrorManager.catch(Socket.getMachine(),'Socket trying gettings options of forbidden pipe',true);
370 callback(false);
371 }
372
373 }
374 catch(error) {
375 ErrorManager.catch(Socket.getMachine(),error,true);
376 callback(false)
377 }
378 })
379
380
381 }
382
383
384 }
385
386
387
388 })
389
390 return namespace;
391}
392
393
394
395const PIPES = SOCKET.EVENTS.PIPES;
396
397function sconsole(socket,msg) {
398 CONSOLE(`-> [${NAMESPACE}]::[nsID:${socket.id}] `+msg)
399}