1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package fr.paris.lutece.plugins.dansmarue.modules.rest.rs;
35
36 import java.io.IOException;
37 import java.io.InputStream;
38 import java.util.Collection;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.Map;
42
43 import javax.inject.Inject;
44 import javax.inject.Named;
45 import javax.servlet.http.HttpServletRequest;
46 import javax.ws.rs.Consumes;
47 import javax.ws.rs.Encoded;
48 import javax.ws.rs.FormParam;
49 import javax.ws.rs.GET;
50 import javax.ws.rs.POST;
51 import javax.ws.rs.Path;
52 import javax.ws.rs.PathParam;
53 import javax.ws.rs.Produces;
54 import javax.ws.rs.core.Context;
55 import javax.ws.rs.core.MediaType;
56
57 import org.apache.commons.lang.StringUtils;
58 import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
59 import org.codehaus.jackson.annotate.JsonMethod;
60 import org.codehaus.jackson.map.DeserializationConfig;
61 import org.codehaus.jackson.map.DeserializationConfig.Feature;
62 import org.codehaus.jackson.map.ObjectMapper;
63
64 import fr.paris.lutece.plugins.dansmarue.business.entities.Adresse;
65 import fr.paris.lutece.plugins.dansmarue.business.entities.PhotoDMR;
66 import fr.paris.lutece.plugins.dansmarue.business.entities.Signalement;
67 import fr.paris.lutece.plugins.dansmarue.business.entities.Source;
68 import fr.paris.lutece.plugins.dansmarue.business.entities.TypeSignalement;
69 import fr.paris.lutece.plugins.dansmarue.business.exceptions.AlreadyFollowedException;
70 import fr.paris.lutece.plugins.dansmarue.business.exceptions.InvalidStateActionException;
71 import fr.paris.lutece.plugins.dansmarue.modules.rest.pojo.ErrorSignalement;
72 import fr.paris.lutece.plugins.dansmarue.modules.rest.pojo.SignalementsPOJO;
73 import fr.paris.lutece.plugins.dansmarue.modules.rest.service.SignRequestService;
74 import fr.paris.lutece.plugins.dansmarue.modules.rest.service.SignalementRestService;
75 import fr.paris.lutece.plugins.dansmarue.modules.rest.service.formatters.ErrorSignalementFormatterJson;
76 import fr.paris.lutece.plugins.dansmarue.modules.rest.util.constants.SignalementRestConstants;
77 import fr.paris.lutece.plugins.dansmarue.modules.rest.util.exception.ParseSignalementFromJSONException;
78 import fr.paris.lutece.plugins.dansmarue.service.SignalementPlugin;
79 import fr.paris.lutece.plugins.dansmarue.service.dto.SignalementDossierDTO;
80 import fr.paris.lutece.plugins.dansmarue.util.constants.LibrarySiraConstants;
81 import fr.paris.lutece.plugins.rest.service.RestConstants;
82 import fr.paris.lutece.plugins.rest.service.formatters.IFormatter;
83 import fr.paris.lutece.plugins.workflowcore.business.action.Action;
84 import fr.paris.lutece.portal.business.user.AdminUser;
85 import fr.paris.lutece.portal.service.datastore.DatastoreService;
86 import fr.paris.lutece.portal.service.template.AppTemplateService;
87 import fr.paris.lutece.portal.service.util.AppLogService;
88 import fr.paris.lutece.portal.service.util.AppPathService;
89 import fr.paris.lutece.portal.service.util.AppPropertiesService;
90 import fr.paris.lutece.util.html.HtmlTemplate;
91 import fr.paris.lutece.util.signrequest.RequestAuthenticator;
92 import net.sf.json.JSONArray;
93 import net.sf.json.JSONException;
94 import net.sf.json.JSONObject;
95
96
97
98
99 @Path( RestConstants.BASE_PATH + SignalementPlugin.PLUGIN_NAME )
100 public class SignalementRest
101 {
102
103
104 private SignalementRestService _signalementRestService;
105
106
107 private SignRequestService _signRequestService;
108
109
110 @Inject
111 @Named( "rest.requestAuthenticator" )
112 private RequestAuthenticator _newWsAuthenticator;
113
114
115
116
117
118
119
120 public void setSignalementRestService( SignalementRestService signalementRestService )
121 {
122 _signalementRestService = signalementRestService;
123 }
124
125
126
127
128
129
130
131 public void setSignRequestService( SignRequestService signRequestService )
132 {
133 _signRequestService = signRequestService;
134 }
135
136
137
138
139
140
141
142
143 @GET
144 @Path( SignalementRestConstants.PATH_WADL )
145 @Produces( MediaType.APPLICATION_XML )
146 public String getWADL( @Context HttpServletRequest request )
147 {
148 StringBuilder sbBase = new StringBuilder( AppPathService.getBaseUrl( request ) );
149
150 if ( sbBase.toString( ).endsWith( SignalementRestConstants.SLASH ) )
151 {
152 sbBase.deleteCharAt( sbBase.length( ) - 1 );
153 }
154
155 sbBase.append( RestConstants.BASE_PATH + SignalementPlugin.PLUGIN_NAME );
156
157 Map<String, Object> model = new HashMap<>( );
158 model.put( SignalementRestConstants.MARK_BASE_URL, sbBase.toString( ) );
159
160 HtmlTemplate t = AppTemplateService.getTemplate( SignalementRestConstants.TEMPLATE_WADL, request.getLocale( ), model );
161
162 return t.getHtml( );
163 }
164
165
166
167
168
169
170
171
172
173
174 @POST
175 @Path( SignalementRestConstants.PATH_API )
176 @Consumes( MediaType.APPLICATION_FORM_URLENCODED )
177 @Produces( MediaType.APPLICATION_JSON )
178 public String processResquestAnswer( @FormParam( SignalementRestConstants.PARAMETERS_JSON_STREAM ) String strJSONStream,
179 @Context HttpServletRequest request )
180 {
181 IFormatter<ErrorSignalement> formatterJson = new ErrorSignalementFormatterJson( );
182
183 if ( StringUtils.isNotBlank( strJSONStream ) )
184 {
185
186 if ( _signRequestService.isRequestAuthenticated( request, strJSONStream ) || _newWsAuthenticator.isRequestAuthenticated( request ) )
187 {
188 try
189 {
190 AppLogService.debug( strJSONStream );
191 return _signalementRestService.processResquestAnswer( strJSONStream, request );
192 }
193 catch( ParseSignalementFromJSONException e )
194 {
195 AppLogService.error( e );
196 return e.getParseError( );
197 }
198 catch( Exception e )
199 {
200 AppLogService.error( e.getMessage( ), e );
201
202 ErrorSignalementansmarue/modules/rest/pojo/ErrorSignalement.html#ErrorSignalement">ErrorSignalement error = new ErrorSignalement( );
203 error.setErrorCode( SignalementRestConstants.ERROR_API_REST );
204 error.setErrorMessage( e.getMessage( ) );
205
206 return formatterJson.format( error );
207 }
208 }
209 }
210 else
211 {
212 ErrorSignalementansmarue/modules/rest/pojo/ErrorSignalement.html#ErrorSignalement">ErrorSignalement error = new ErrorSignalement( );
213 error.setErrorCode( SignalementRestConstants.ERROR_EMPTY_JSON_REQUEST );
214 error.setErrorMessage( StringUtils.EMPTY );
215
216 return formatterJson.format( error );
217 }
218
219 return null;
220 }
221
222
223
224
225
226
227
228
229
230
231 @GET
232 @Path( SignalementRestConstants.PATH_TEST_GET )
233 @Produces( MediaType.TEXT_PLAIN )
234 public String processResquestAnswerTest( @PathParam( SignalementRestConstants.PARAMETERS_JSON_STREAM ) String strJSONStream,
235 @Context HttpServletRequest request )
236 {
237 IFormatter<ErrorSignalement> formatterJson = new ErrorSignalementFormatterJson( );
238
239 if ( StringUtils.isNotBlank( request.getParameter( SignalementRestConstants.PARAMETERS_JSON_STREAM ) ) )
240 {
241 try
242 {
243 return _signalementRestService.processResquestAnswer( request.getParameter( SignalementRestConstants.PARAMETERS_JSON_STREAM ), request );
244 }
245 catch( ParseSignalementFromJSONException e )
246 {
247 AppLogService.error( e );
248 return e.getParseError( );
249 }
250 catch( JSONException e )
251 {
252 AppLogService.error( e.getMessage( ), e );
253
254 ErrorSignalementansmarue/modules/rest/pojo/ErrorSignalement.html#ErrorSignalement">ErrorSignalement error = new ErrorSignalement( );
255 error.setErrorCode( SignalementRestConstants.ERROR_BAD_JSON_REQUEST );
256 error.setErrorMessage( e.getMessage( ) );
257
258 return formatterJson.format( error );
259 }
260 }
261 else
262 {
263 ErrorSignalementansmarue/modules/rest/pojo/ErrorSignalement.html#ErrorSignalement">ErrorSignalement error = new ErrorSignalement( );
264 error.setErrorCode( SignalementRestConstants.ERROR_EMPTY_JSON_REQUEST );
265 error.setErrorMessage( StringUtils.EMPTY );
266
267 return formatterJson.format( error );
268 }
269 }
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300 @POST
301 @Path( SignalementRestConstants.PATH_API + SignalementRestConstants.SLASH + SignalementRestConstants.PATH_CHANGE_STATUS + "/{id}/{reference}/{token}" )
302 @Produces( MediaType.APPLICATION_JSON )
303 public String changeStatus( @Context HttpServletRequest request, @PathParam( value = SignalementRestConstants.JSON_TAG_INCIDENT_ID ) String id,
304 @PathParam( value = SignalementRestConstants.JSON_TAG_REFERENCE ) String reference,
305 @PathParam( value = SignalementRestConstants.JSON_TAG_TOKEN ) String token,
306 @FormParam( value = SignalementRestConstants.JSON_TAG_STATUS ) String status,
307 @FormParam( value = SignalementRestConstants.JSON_TAG_INCIDENT_CHOSEN_MESSAGE ) String chosenMessage,
308 @FormParam( value = SignalementRestConstants.JSON_TAG_INCIDENT_DATE_REEL_ACTION ) String date,
309 @FormParam( value = SignalementRestConstants.JSON_TAG_INCIDENT_COMMENT ) String comment,
310 @FormParam( value = SignalementRestConstants.JSON_TAG_INCIDENT_ID_REJET ) String motifRejet,
311 @FormParam( value = SignalementRestConstants.JSON_TAG_INCIDENT_DATE_PROGRAMMATION ) String dateDeProgrammation,
312 @FormParam( value = SignalementRestConstants.JSON_TAG_INCIDENT_TYPE_ANOMALIE ) String idTypeAnomalie,
313 @FormParam( value = SignalementRestConstants.JSON_TAG_INCIDENT_PHOTO ) String photo )
314 {
315 AppLogService.info( "changeStatus call from client : " + request.getRemoteHost( ) + " ( " + request.getRemoteAddr( ) + " ) " );
316 AppLogService.info( "call parameters : id=" + id + " reference=" + reference + " token=" + token + " status=" + status + " chosenMessage="
317 + chosenMessage + " date=" + date + " comment=" + comment + " motifRejet=" + motifRejet + " dateDeProgrammation=" + dateDeProgrammation
318 + " idTypeAnomalie=" + idTypeAnomalie );
319
320 JSONObject jsonObject = createJSONStatusObject( id, reference, token, status, chosenMessage, date, comment, motifRejet, dateDeProgrammation,
321 idTypeAnomalie, photo );
322
323 AppLogService.info( "parameters to json : "
324 + createJSONStatusObject( id, reference, token, status, chosenMessage, date, comment, motifRejet, dateDeProgrammation, idTypeAnomalie, null ) );
325 String jsonResponse = _signalementRestService.changeStatus( jsonObject, request );
326 AppLogService.info( "response send : " + jsonResponse );
327
328 return jsonResponse;
329 }
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358 public JSONObject createJSONStatusObject( String id, String reference, String token, String status, String chosenMessage, String date, String comment,
359 String motifRejet, String dateDeProgrammation, String idTypeAnomalie, String photo )
360 {
361 JSONObject jsonObject = new JSONObject( );
362 jsonObject.accumulate( SignalementRestConstants.JSON_TAG_REQUEST, SignalementRestConstants.REQUEST_TYPE_CHANGE_STATUS );
363
364 JSONObject jsonAnswer = new JSONObject( );
365 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_ID, id );
366 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_REFERENCE, reference );
367 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_TOKEN, token );
368 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_STATUS, status );
369 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_CHOSEN_MESSAGE, chosenMessage );
370 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_DATE_REEL_ACTION, date );
371 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_COMMENT, comment );
372 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_ID_REJET, motifRejet );
373 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_DATE_PROGRAMMATION, dateDeProgrammation );
374 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_TYPE_ANOMALIE, idTypeAnomalie );
375 jsonAnswer.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_PHOTO, photo );
376
377 jsonObject.accumulate( SignalementRestConstants.JSON_TAG_ANSWER, jsonAnswer );
378 return jsonObject;
379 }
380
381
382
383
384
385
386
387
388
389
390 @POST
391 @Path( SignalementRestConstants.PATH_API + SignalementRestConstants.SLASH + SignalementRestConstants.PATH_PHOTO )
392 @Produces( MediaType.APPLICATION_JSON )
393 public String updatePictureSignalement( @Context HttpServletRequest request, InputStream requestBodyStream )
394 {
395 return _signalementRestService.updatePictureIncident( request, requestBodyStream );
396 }
397
398
399
400
401
402
403
404
405
406 @GET
407 @Path( SignalementRestConstants.PATH_SIGNALEMENT_A_ARCHIVER_REJETE )
408 @Produces( MediaType.APPLICATION_JSON )
409 public SignalementsPOJO serviceAArchiverRejete( @Context HttpServletRequest request )
410 {
411 return _signalementRestService.signalementAArchiverRejete( );
412 }
413
414
415
416
417
418
419
420
421 @GET
422 @Path( SignalementRestConstants.PATH_SIGNALEMENT_A_ARCHIVER_SERVICE_FAIT )
423 @Produces( MediaType.APPLICATION_JSON )
424 public SignalementsPOJO serviceAArchiverServiceFait( @Context HttpServletRequest request )
425 {
426 return _signalementRestService.signalementAArchiverServiceFait( );
427 }
428
429
430
431
432
433
434
435
436 @POST
437 @Consumes( {
438 MediaType.APPLICATION_JSON
439 } )
440 @Produces( {
441 MediaType.APPLICATION_JSON + ";charset=utf-8"
442 } )
443 @Path( LibrarySiraConstants.REST_TYPE_SIGNALEMENT_SERVICE )
444 public String getAllSousTypeSignalementCascade( String parameters )
445 {
446
447 try
448 {
449 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
450 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
451
452 JSONArray array = (JSONArray) object.get( "listTypeSignalement" );
453 List<TypeSignalement> typeSignalement = mapper.readValue( array.toString( ),
454 mapper.getTypeFactory( ).constructCollectionType( List.class, TypeSignalement.class ) );
455 _signalementRestService.getAllSousTypeSignalementCascade( (Integer) object.get( "typeSignalementId" ), typeSignalement );
456 return mapper.writeValueAsString( typeSignalement );
457
458 }
459 catch( IOException e )
460 {
461 AppLogService.error( e );
462 return formatJsonError( SignalementRestConstants.ERROR_GET_ALL_SOUS_TYPE_SIGNALEMENT_CASCADE, e.getMessage( ) );
463
464 }
465 }
466
467
468
469
470
471
472
473
474 @POST
475 @Consumes( {
476 MediaType.APPLICATION_JSON
477 } )
478 @Produces( {
479 MediaType.APPLICATION_JSON + ";charset=utf-8"
480 } )
481 @Path( LibrarySiraConstants.REST_GET_SIGNALEMENT_BY_ID )
482 public String getSignalementById( String parameters )
483 {
484 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
485 try
486 {
487 JSONObject object = mapper.readValue( parameters, JSONObject.class );
488 Long lIdSignalement = Long.valueOf( (String) object.get( SignalementRestConstants.JSON_TAG_SIGNALEMENT_ID ) );
489
490 SignalementDossierDTO dto = new SignalementDossierDTO( );
491
492 Signalement signalement = _signalementRestService.getSignalementByID( lIdSignalement );
493 dto.setNumRessource( signalement.getNumeroSignalement( ) );
494 dto.setPhotos( _signalementRestService.getPhotosBySignalementId( lIdSignalement ) );
495 dto.setAdresse( _signalementRestService.getAdresseBySignalementId( lIdSignalement ) );
496 dto.setDateCreation( signalement.getDateCreation( ) );
497 dto.setHeureCreation( signalement.getHeureCreation( ) );
498 dto.setId( signalement.getId( ).intValue( ) );
499 dto.setType( signalement.getPrefix( ) );
500
501 return mapper.writeValueAsString( dto );
502 }
503 catch( IOException e )
504 {
505 AppLogService.error( e );
506 return formatJsonError( SignalementRestConstants.ERROR_GET_SIGNALEMENT_BY_ID, e.getMessage( ) );
507 }
508 }
509
510
511
512
513
514
515
516
517 @POST
518 @Consumes( {
519 MediaType.APPLICATION_JSON
520 } )
521 @Produces( {
522 MediaType.APPLICATION_JSON + ";charset=utf-8"
523 } )
524 @Path( "getAddressItem" )
525 public String getAddressItem( String parameters )
526 {
527 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
528 try
529 {
530 return mapper.writeValueAsString( _signalementRestService.getAddressItem( parameters ) );
531 }
532 catch( IOException e )
533 {
534 AppLogService.error( e );
535 return formatJsonError( SignalementRestConstants.ERROR_GET_SIGNALEMENT_BY_ID, e.getMessage( ) );
536 }
537 }
538
539
540
541
542
543
544
545
546 @POST
547 @Consumes( {
548 MediaType.APPLICATION_JSON
549 } )
550 @Produces( {
551 MediaType.APPLICATION_JSON + ";charset=utf-8"
552 } )
553 @Path( "getGeomFromLambertToWgs84" )
554 public String getGeomFromLambertToWgs84( String parameters )
555 {
556 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
557 try
558 {
559 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
560 Double dLatLambert = (Double) object.get( "dLatLambert" );
561 Double dLngLambert = (Double) object.get( "dLngLambert" );
562
563 return mapper.writeValueAsString( _signalementRestService.getGeomFromLambertToWgs84( dLatLambert, dLngLambert ) );
564 }
565 catch( IOException e )
566 {
567 AppLogService.error( e );
568 return formatJsonError( SignalementRestConstants.ERROR_GET_SIGNALEMENT_BY_ID, e.getMessage( ) );
569
570 }
571 }
572
573
574
575
576
577
578
579
580 @POST
581 @Consumes( {
582 MediaType.APPLICATION_JSON
583 } )
584 @Produces( {
585 MediaType.APPLICATION_JSON + ";charset=utf-8"
586 } )
587 @Path( "getGeomFromLambert93ToWgs84" )
588 public String getGeomFromLambert93ToWgs84( String parameters )
589 {
590 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
591 try
592 {
593 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
594 Double dLatLambert = (Double) object.get( "dLatLambert" );
595 Double dLngLambert = (Double) object.get( "dLngLambert" );
596
597 return mapper.writeValueAsString( _signalementRestService.getGeomFromLambert93ToWgs84( dLatLambert, dLngLambert ) );
598 }
599 catch( IOException e )
600 {
601 AppLogService.error( e );
602 return formatJsonError( SignalementRestConstants.ERROR_GET_GEOM_FROM_LAMBERT_TO_WQ84, e.getMessage( ) );
603 }
604 }
605
606
607
608
609
610
611
612
613 @POST
614 @Consumes( {
615 MediaType.APPLICATION_JSON
616 } )
617 @Produces( {
618 MediaType.APPLICATION_JSON + ";charset=utf-8"
619 } )
620 @Path( "findAllSignalementInPerimeterWithDTO" )
621 public String findAllSignalementInPerimeterWithDTO( String parameters )
622 {
623 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
624 try
625 {
626 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
627 Double lat = (Double) object.get( "lat" );
628 Double lng = (Double) object.get( "lng" );
629 Integer radius = (Integer) object.get( "radius" );
630
631 return mapper.writeValueAsString( _signalementRestService.findAllSignalementInPerimeterWithDTO( lat, lng, radius ) );
632 }
633 catch( IOException e )
634 {
635 AppLogService.error( e );
636 return formatJsonError( SignalementRestConstants.ERROR_FIND_ALL_SIGNALLEMENT_IN_PERIMETER_WITH_DTO, e.getMessage( ) );
637
638 }
639 }
640
641
642
643
644
645
646
647
648 @POST
649 @Consumes( {
650 MediaType.APPLICATION_JSON
651 } )
652 @Produces( {
653 MediaType.APPLICATION_JSON + ";charset=utf-8"
654 } )
655 @Path( "getDistanceBetweenSignalement" )
656 public String getDistanceBetweenSignalement( String parameters )
657 {
658 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
659 try
660 {
661 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
662 Double lat1 = (Double) object.get( "lat1" );
663 Double lng1 = (Double) object.get( "lng1" );
664 Double lat2 = (Double) object.get( "lat2" );
665 Double lng2 = (Double) object.get( "lng2" );
666
667 return mapper.writeValueAsString( _signalementRestService.getDistanceBetweenSignalement( lat1, lng1, lat2, lng2 ) );
668 }
669 catch( IOException e )
670 {
671 AppLogService.error( e );
672 return formatJsonError( SignalementRestConstants.ERROR_GET_DISTANCE_BETWEEN_SIGNALEMENT, e.getMessage( ) );
673
674 }
675 }
676
677
678
679
680
681
682
683
684 @POST
685 @Consumes( {
686 MediaType.APPLICATION_JSON
687 } )
688 @Produces( {
689 MediaType.APPLICATION_JSON + ";charset=utf-8"
690 } )
691 @Path( "isSignalementFollowable" )
692 public String isSignalementFollowableAndisSignalementFollowedByUser( String parameters )
693 {
694 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
695 try
696 {
697 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
698 Integer nIdSignalement = (Integer) object.get( SignalementRestConstants.JSON_TAG_SIGNALEMENT_ID_N );
699 String userGuid = (String) object.get( "userGuid" );
700
701 return mapper.writeValueAsString( _signalementRestService.isSignalementFollowableAndisSignalementFollowedByUser( nIdSignalement, userGuid ) );
702 }
703 catch( IOException e )
704 {
705 AppLogService.error( e );
706 return formatJsonError( SignalementRestConstants.ERROR_IS_SIGNALEMENT_FOLLOWABLE_AND_IS_SIGNALEMENT_FOLLOWED_BY_USER, e.getMessage( ) );
707
708 }
709 }
710
711
712
713
714
715
716 @GET
717 @Consumes( {
718 MediaType.APPLICATION_JSON
719 } )
720 @Produces( {
721 MediaType.APPLICATION_JSON + ";charset=utf-8"
722 } )
723 @Path( "getAllPriorite" )
724 @Encoded
725 public String getAllPriorite( )
726 {
727 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
728 try
729 {
730 return mapper.writeValueAsString( _signalementRestService.getAllPriorite( ) );
731 }
732 catch( IOException e )
733 {
734 AppLogService.error( e );
735 return formatJsonError( SignalementRestConstants.ERROR_GET_ALL_PRIORITE, e.getMessage( ) );
736
737 }
738 }
739
740
741
742
743
744
745
746
747
748 @POST
749 @Consumes( {
750 MediaType.APPLICATION_JSON
751 } )
752 @Produces( {
753 MediaType.APPLICATION_JSON + ";charset=utf-8"
754 } )
755 @Path( "loadPrioriteById" )
756 public String loadPrioriteById( String parameters )
757 {
758 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
759 try
760 {
761 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
762 long lId = object.getLong( "lId" );
763
764 return mapper.writeValueAsString( _signalementRestService.loadPrioriteById( lId ) );
765 }
766 catch( IOException e )
767 {
768 AppLogService.error( e );
769 return formatJsonError( SignalementRestConstants.ERROR_LOAD_PRIORITE_BY_ID, e.getMessage( ) );
770
771 }
772 }
773
774
775
776
777
778
779
780
781
782 @POST
783 @Consumes( {
784 MediaType.APPLICATION_JSON
785 } )
786 @Produces( {
787 MediaType.APPLICATION_JSON + ";charset=utf-8"
788 } )
789 @Path( "getArrondissementByGeom" )
790 public String getArrondissementByGeom( String parameters )
791 {
792 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
793 try
794 {
795 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
796 Double lat = ( (Number) object.get( "lat" ) ).doubleValue( );
797 Double lng = ( (Number) object.get( "lng" ) ).doubleValue( );
798
799 return mapper.writeValueAsString( _signalementRestService.getArrondissementByGeom( lng, lat ) );
800 }
801 catch( IOException e )
802 {
803 AppLogService.error( e );
804 return formatJsonError( SignalementRestConstants.ERROR_GET_ARRONDISSEMENT_BY_GEOM, e.getMessage( ) );
805
806 }
807 }
808
809
810
811
812
813
814
815
816
817 @GET
818 @Produces( {
819 MediaType.APPLICATION_JSON + ";charset=utf-8"
820 } )
821 @Path( "getTypeSignalementTree" )
822 public String getTypeSignalementTree( @Context HttpServletRequest request )
823 {
824 return _signalementRestService.getCategoriesListJson( );
825
826 }
827
828
829
830
831
832
833
834
835
836
837 @GET
838 @Produces( {
839 MediaType.APPLICATION_JSON + ";charset=utf-8"
840 } )
841 @Path( "getTypeSignalementTreeForSource/{idSource}" )
842 public String getTypeSignalementTreeForSource( @PathParam( SignalementRestConstants.PARAMETERS_ID_SOURCE ) Integer idSource,
843 @Context HttpServletRequest request )
844 {
845 return _signalementRestService.getCategoriesListJsonForSource( idSource );
846 }
847
848
849
850
851
852
853
854
855
856
857 @GET
858 @Produces( {
859 MediaType.APPLICATION_JSON + ";charset=utf-8"
860 } )
861 @Path( "getActualite/{versionActualite}" )
862 public String getActualite( @PathParam( SignalementRestConstants.PARAMETERS_VERSION_ACTUALITE ) int versionActualite,
863 @Context HttpServletRequest request )
864 {
865 return _signalementRestService.getActualiteListJson( versionActualite );
866 }
867
868
869
870
871
872
873
874
875
876
877 @GET
878 @Produces( {
879 MediaType.APPLICATION_JSON + ";charset=utf-8"
880 } )
881 @Path( "getAide/{versionAide}" )
882 public String getAide( @PathParam( SignalementRestConstants.PARAMETERS_VERSION_AIDE ) int versionAide,
883 @Context HttpServletRequest request )
884 {
885 return _signalementRestService.getAideListJson( versionAide );
886 }
887
888
889
890
891
892
893
894
895
896
897 @GET
898 @Produces( {
899 MediaType.APPLICATION_JSON + ";charset=utf-8"
900 } )
901 @Path( "getInfosForSource/{idSource}" )
902 public String getInfosForSource( @PathParam( SignalementRestConstants.PARAMETERS_ID_SOURCE ) Integer idSource, @Context HttpServletRequest request )
903 {
904 ObjectMapper mapper = new ObjectMapper( );
905 mapper.configure( DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false );
906
907 Source source = _signalementRestService.getInfosForSource( idSource );
908
909 try
910 {
911 return mapper.writeValueAsString( source );
912 }
913 catch( IOException e )
914 {
915 AppLogService.error( e );
916 return formatJsonError( SignalementRestConstants.ERROR_BAD_JSON_REQUEST, e.getMessage( ) );
917 }
918 }
919
920
921
922
923
924
925
926
927 @POST
928 @Consumes( {
929 MediaType.APPLICATION_JSON
930 } )
931 @Produces( {
932 MediaType.APPLICATION_JSON + ";charset=utf-8"
933 } )
934 @Path( "getTypeSignalement" )
935 public String getTypeSignalement( String parameters )
936 {
937 JSONObject object;
938
939 try
940 {
941 object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
942 Integer nIdSignalement = (Integer) object.get( "nIdSignalement" );
943 TypeSignalement typeSignalement = _signalementRestService.getTypeSignalement( nIdSignalement );
944
945 return formatJsonTypeSignalement( typeSignalement );
946 }
947 catch( IOException e )
948 {
949 AppLogService.error( e );
950 return formatJsonError( SignalementRestConstants.ERROR_BAD_JSON_REQUEST, e.getMessage( ) );
951
952 }
953 }
954
955
956
957
958
959
960 @GET
961 @Produces( {
962 MediaType.APPLICATION_JSON + ";charset=utf-8"
963 } )
964 @Path( "isDmrOnline" )
965 public String isDmrOnline( )
966 {
967 JSONObject jObject = new JSONObject( );
968 jObject.put( "online", true );
969
970 String messageInformation = DatastoreService.getDataValue( "sitelabels.site_property.signalement.mobile.message.information", null );
971 if ( StringUtils.isNotBlank( messageInformation ) )
972 {
973 jObject.accumulate( "message_information", messageInformation );
974 }
975
976 return jObject.toString( );
977 }
978
979
980
981
982
983
984
985
986 @POST
987 @Consumes( {
988 MediaType.APPLICATION_JSON
989 } )
990 @Produces( {
991 MediaType.APPLICATION_JSON + ";charset=utf-8"
992 } )
993 @Path( "findByIdTypeSignalement" )
994 public String findByIdTypeSignalement( String parameters )
995 {
996 JSONObject object;
997
998 try
999 {
1000 object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
1001 Integer nIdSignalement = (Integer) object.get( "nIdSignalement" );
1002 TypeSignalement typeSignalement = _signalementRestService.findByIdTypeSignalement( nIdSignalement );
1003
1004 return formatJsonTypeSignalement( typeSignalement );
1005 }
1006 catch( IOException e )
1007 {
1008 AppLogService.error( e );
1009 return formatJsonError( SignalementRestConstants.ERROR_BAD_JSON_REQUEST, e.getMessage( ) );
1010
1011 }
1012 }
1013
1014
1015
1016
1017
1018
1019
1020
1021 @POST
1022 @Consumes( {
1023 MediaType.APPLICATION_JSON
1024 } )
1025 @Produces( {
1026 MediaType.APPLICATION_JSON + ";charset=utf-8"
1027 } )
1028 @Path( "addFollower" )
1029 public String addFollower( String parameters )
1030 {
1031 JSONObject jObject = new JSONObject( );
1032 try
1033 {
1034 JSONObject object;
1035 object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
1036 Long signalementId = object.getLong( "signalementId" );
1037 String guid = object.getString( "guid" );
1038 String strUDID = object.getString( "strUDID" );
1039 String email = object.getString( "email" );
1040 String device = object.getString( "device" );
1041 String userToken = object.getString( "userToken" );
1042 boolean createUser = object.getBoolean( "createUser" );
1043
1044 _signalementRestService.addFollower( signalementId, guid, strUDID, email, device, userToken, createUser );
1045 jObject.put( "isAddOk", true );
1046
1047 }
1048 catch( InvalidStateActionException | AlreadyFollowedException | IOException e )
1049 {
1050 AppLogService.error( e );
1051 jObject.put( "isAddOk", false );
1052 }
1053 return jObject.toString( );
1054 }
1055
1056
1057
1058
1059
1060
1061
1062
1063 @POST
1064 @Consumes( {
1065 MediaType.APPLICATION_JSON
1066 } )
1067 @Produces( {
1068 MediaType.APPLICATION_JSON + ";charset=utf-8"
1069 } )
1070 @Path( "getDossiersCourrantsByGeomWithLimit" )
1071 public String getDossiersCourrantsByGeomWithLimit( String parameters )
1072 {
1073
1074 JSONObject object;
1075 try
1076 {
1077 object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
1078 Double longitude = object.getDouble( "longitude" );
1079 Double latitude = object.getDouble( "latitude" );
1080
1081 return _signalementRestService.getDossiersCourrantsByGeomWithLimit( longitude, latitude );
1082 }
1083 catch( IOException e )
1084 {
1085 AppLogService.error( e );
1086 return formatJsonError( SignalementRestConstants.ERROR_BAD_JSON_REQUEST, e.getMessage( ) );
1087 }
1088
1089 }
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100 private String formatJsonError( int errorCode, String errorMessage )
1101 {
1102 IFormatter<ErrorSignalement> formatterJson = new ErrorSignalementFormatterJson( );
1103 ErrorSignalementansmarue/modules/rest/pojo/ErrorSignalement.html#ErrorSignalement">ErrorSignalement error = new ErrorSignalement( );
1104 error.setErrorCode( errorCode );
1105 error.setErrorMessage( errorMessage );
1106 return formatterJson.format( error );
1107 }
1108
1109
1110
1111
1112
1113
1114
1115
1116 private String formatJsonTypeSignalement( TypeSignalement typeSignalement )
1117 {
1118
1119 if ( typeSignalement == null )
1120 {
1121 return null;
1122 }
1123
1124 JSONObject json = new JSONObject( );
1125 json.accumulate( "id", typeSignalement.getId( ) );
1126 json.accumulate( "libelle", typeSignalement.getLibelle( ).replace( "\"", "" ) );
1127 json.accumulate( "actif", typeSignalement.getActif( ) );
1128 json.accumulate( "unit", typeSignalement.getUnit( ) );
1129 json.accumulate( "idTypeSignalementParent", typeSignalement.getIdTypeSignalementParent( ) );
1130 json.accumulate( "image", typeSignalement.getImage( ) );
1131 json.accumulate( "ordre", typeSignalement.getOrdre( ) );
1132 json.accumulate( "imageUrl", typeSignalement.getImageUrl( ) );
1133 json.accumulate( "idCategory", typeSignalement.getIdCategory( ) );
1134 json.accumulate( "alias", typeSignalement.getAlias( ) );
1135 json.accumulate( "aliasMobile", typeSignalement.getAliasMobile( ) );
1136 if ( typeSignalement.isHorsDMR( ) )
1137 {
1138 json.accumulate( SignalementRestConstants.JSON_TAG_HORS_DMR, typeSignalement.isHorsDMR( ) );
1139 json.accumulate( SignalementRestConstants.JSON_TAG_MESAGE_HORS_DMR, typeSignalement.getMessageHorsDMR( ) );
1140 }
1141
1142 if ( typeSignalement.getTypeSignalementParent( ) != null )
1143 {
1144 json.accumulate( "typeSignalementParent", formatJsonTypeSignalement( typeSignalement.getTypeSignalementParent( ) ) );
1145 }
1146
1147 return json.toString( );
1148 }
1149
1150
1151
1152
1153
1154
1155
1156
1157 @POST
1158 @Consumes( {
1159 MediaType.APPLICATION_JSON
1160 } )
1161 @Produces( {
1162 MediaType.APPLICATION_JSON + ";charset=utf-8"
1163 } )
1164 @Path( LibrarySiraConstants.REST_GET_LIST_WORKFLOW_ACTION )
1165 public String getWorkflowActions( String parameters )
1166 {
1167 try
1168 {
1169 JSONObject object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
1170 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY ).configure( Feature.FAIL_ON_UNKNOWN_PROPERTIES, false );
1171
1172 int idSignalement = object.getInt( SignalementRestConstants.JSON_TAG_SIGNALEMENT_ID_N );
1173 AdminUser user = mapper.readValue( object.get( "user" ).toString( ), AdminUser.class );
1174
1175 Collection<Action> listActionsPossibles = _signalementRestService.getListActionsByIdSignalementAndUser( idSignalement, user );
1176
1177 return mapper.writeValueAsString( listActionsPossibles );
1178
1179 }
1180 catch( IOException e )
1181 {
1182 AppLogService.error( e );
1183 return formatJsonError( SignalementRestConstants.ERROR_WORKFLOW_ACTION, e.getMessage( ) );
1184 }
1185
1186 }
1187
1188
1189
1190
1191
1192
1193
1194
1195 @POST
1196 @Consumes( {
1197 MediaType.APPLICATION_JSON
1198 } )
1199 @Produces( {
1200 MediaType.APPLICATION_JSON + ";charset=utf-8"
1201 } )
1202 @Path( "sauvegarderSignalement" )
1203 public String sauvegarderSignalement( String parameters )
1204 {
1205 JSONObject object;
1206 try
1207 {
1208 object = new ObjectMapper( ).readValue( parameters, JSONObject.class );
1209 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
1210 mapper.configure( DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false );
1211
1212 Signalement demandeSignalement = mapper.readValue( object.get( "demandeSignalement" ).toString( ), Signalement.class );
1213
1214 String userName = object.containsKey( "userName" ) ? object.getString( "userName" ) : null;
1215 String userMail = object.containsKey( "userMail" ) ? object.getString( "userMail" ) : null;
1216
1217 return _signalementRestService.sauvegarderSignalement( demandeSignalement, userName, userMail ).toString( );
1218
1219 }
1220 catch( IOException e )
1221 {
1222 AppLogService.error( e );
1223 return formatJsonError( SignalementRestConstants.ERROR_SAVE_SIGNALEMENT, e.getMessage( ) );
1224 }
1225
1226 }
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237 @POST
1238 @Consumes( {
1239 MediaType.APPLICATION_JSON
1240 } )
1241 @Produces( {
1242 MediaType.APPLICATION_JSON + ";charset=utf-8"
1243 } )
1244 @Path( "validateServiceFaitSignalement" )
1245 public String validateServiceFaitSignalement( String parameters, @Context HttpServletRequest request )
1246 {
1247 JSONObject jObject = new JSONObject( );
1248 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
1249 mapper.configure( DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false );
1250 JSONObject object;
1251 try
1252 {
1253 object = mapper.readValue( parameters, JSONObject.class );
1254 String token = object.containsKey( SignalementRestConstants.JSON_TAG_TOKEN ) ? object.getString( SignalementRestConstants.JSON_TAG_TOKEN ) : null;
1255 Signalement signalement = _signalementRestService.getSignalementByToken( token );
1256
1257 jObject.put( "isServiceFait", _signalementRestService.validateServiceFaitSignalement( signalement, request ) );
1258
1259 return jObject.toString( );
1260 }
1261 catch( IOException e )
1262 {
1263 AppLogService.error( e );
1264 return formatJsonError( SignalementRestConstants.ERROR_GET_SIGNALEMENT_BY_TOKEN, e.getMessage( ) );
1265 }
1266
1267 }
1268
1269
1270
1271
1272
1273
1274
1275
1276 @POST
1277 @Consumes( {
1278 MediaType.APPLICATION_JSON
1279 } )
1280 @Produces( {
1281 MediaType.APPLICATION_JSON + ";charset=utf-8"
1282 } )
1283 @Path( "getSignalementByToken" )
1284 public String getSignalementByToken( String parameters )
1285 {
1286 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
1287 mapper.configure( DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false );
1288 JSONObject object;
1289 try
1290 {
1291 object = mapper.readValue( parameters, JSONObject.class );
1292 String token = object.containsKey( SignalementRestConstants.JSON_TAG_TOKEN ) ? object.getString( SignalementRestConstants.JSON_TAG_TOKEN ) : null;
1293 Signalement signalement = _signalementRestService.getSignalementByToken( token );
1294
1295 return formatJsonSignalement( signalement );
1296 }
1297 catch( IOException e )
1298 {
1299 AppLogService.error( e );
1300 return formatJsonError( SignalementRestConstants.ERROR_GET_SIGNALEMENT_BY_TOKEN, e.getMessage( ) );
1301 }
1302
1303 }
1304
1305
1306
1307
1308
1309
1310
1311
1312 private String formatJsonSignalement( Signalement signalement )
1313 {
1314
1315 if ( signalement == null )
1316 {
1317 return null;
1318 }
1319
1320 JSONObject json = new JSONObject( );
1321 JSONObject adresse = new JSONObject( );
1322
1323 for ( Adresse adr : signalement.getAdresses( ) )
1324 {
1325 adresse.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_ID, adr.getId( ) );
1326 adresse.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_ADDRESS, adr.getAdresse( ) );
1327 adresse.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_LAT, adr.getLat( ) );
1328 adresse.accumulate( SignalementRestConstants.JSON_TAG_INCIDENT_LNG, adr.getLng( ) );
1329 }
1330
1331 json.accumulate( "id", signalement.getId( ) );
1332 json.accumulate( "adresses", adresse );
1333 json.accumulate( "prefix", signalement.getPrefix( ) );
1334 json.accumulate( "annee", signalement.getAnnee( ) );
1335 json.accumulate( "mois", signalement.getMois( ) );
1336 json.accumulate( "numero", signalement.getNumero( ) );
1337 json.accumulate( "typeSignalement", formatJsonTypeSignalement( signalement.getTypeSignalement( ) ) );
1338
1339 if ( signalement.getPhotos( ) != null )
1340 {
1341 for ( PhotoDMR photo : signalement.getPhotos( ) )
1342 {
1343 String token = "";
1344 if(StringUtils.isNotBlank( photo.getCheminPhoto( ) )) {
1345 token = "_"+photo.getCheminPhoto( ).split("_")[0];
1346 }
1347
1348 if ( photo.getVue( ).equals( SignalementRestConstants.VUE_PRES ) )
1349 {
1350 json.accumulate( "pictureClose", AppPropertiesService.getProperty( SignalementRestConstants.PROPERTY_URL_PICTURE ) + photo.getId( )+token );
1351 }
1352 else if ( photo.getVue( ).equals( SignalementRestConstants.VUE_ENSEMBLE ) )
1353 {
1354 json.accumulate( "pictureFar", AppPropertiesService.getProperty( SignalementRestConstants.PROPERTY_URL_PICTURE ) + photo.getId( )+token );
1355 }
1356 else if ( photo.getVue( ).equals( SignalementRestConstants.VUE_SERVICE_FAIT ) )
1357 {
1358 json.accumulate( "pictureServiceFait", AppPropertiesService.getProperty( SignalementRestConstants.PROPERTY_URL_PICTURE ) + photo.getId( )+token );
1359 }
1360 }
1361 }
1362
1363 return json.toString( );
1364 }
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375 @POST
1376 @Consumes( {
1377 MediaType.APPLICATION_JSON
1378 } )
1379 @Produces( {
1380 MediaType.APPLICATION_JSON + ";charset=utf-8"
1381 } )
1382 @Path( "getHistorySignalement" )
1383 public String getHistorySignalement( String parameters, @Context HttpServletRequest request )
1384 {
1385 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
1386 mapper.configure( DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false );
1387 JSONObject object;
1388 try
1389 {
1390 object = mapper.readValue( parameters, JSONObject.class );
1391 String id = object.containsKey( SignalementRestConstants.JSON_TAG_SIGNALEMENT_ID )
1392 ? object.getString( SignalementRestConstants.JSON_TAG_SIGNALEMENT_ID )
1393 : null;
1394
1395 Integer idSignalement = mapper.readValue( id, Integer.class );
1396
1397 JSONObject response = _signalementRestService.getHistorySignalement( idSignalement, request );
1398
1399 return mapper.writeValueAsString( response );
1400 }
1401 catch( IOException e )
1402 {
1403 AppLogService.error( e );
1404 return formatJsonError( SignalementRestConstants.ERROR_GET_HISTORY_SIGNALEMENT, e.getMessage( ) );
1405 }
1406
1407 }
1408
1409
1410
1411
1412
1413
1414 @GET
1415 @Produces( {
1416 MediaType.APPLICATION_JSON + ";charset=utf-8"
1417 } )
1418 @Path( "getTypeMessageServiceFait" )
1419 public String getTypeMessageServiceFait( )
1420 {
1421 ObjectMapper mapper = new ObjectMapper( ).setVisibility( JsonMethod.FIELD, Visibility.ANY );
1422 mapper.configure( DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false );
1423
1424 try
1425 {
1426 JSONObject response = _signalementRestService.selectMessageServiceFaitPresta( );
1427
1428 return mapper.writeValueAsString( response );
1429
1430 }
1431 catch( IOException e )
1432 {
1433 AppLogService.error( e );
1434 return formatJsonError( SignalementRestConstants.ERROR_BAD_JSON_REQUEST, e.getMessage( ) );
1435
1436 }
1437 }
1438
1439
1440
1441
1442
1443
1444 @GET
1445 @Produces( {
1446 MediaType.APPLICATION_JSON + ";charset=utf-8"
1447 } )
1448 @Path( "getRaisonRejet" )
1449 public String getRaisonRejet( )
1450 {
1451 ObjectMapper mapper = new ObjectMapper( );
1452 mapper.configure( DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false );
1453
1454 try
1455 {
1456 return mapper.writeValueAsString( _signalementRestService.getRaisonRejet( ) );
1457 }
1458 catch( IOException e )
1459 {
1460 AppLogService.error( e );
1461 return formatJsonError( SignalementRestConstants.ERROR_BAD_JSON_REQUEST, e.getMessage( ) );
1462
1463 }
1464 }
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478 @GET
1479 @Produces( {
1480 MediaType.APPLICATION_JSON + ";charset=utf-8"
1481 } )
1482 @Path( "getAnomalieByNumber/{number}" )
1483 public String getAnomalieByNumber( @PathParam( SignalementRestConstants.PARAMETER_NUMBER ) String number, @Context HttpServletRequest request )
1484 {
1485 return _signalementRestService.getAnomalieByNumber( number, "-1" );
1486 }
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498 @GET
1499 @Produces( {
1500 MediaType.APPLICATION_JSON + ";charset=utf-8"
1501 } )
1502 @Path( "searchIncidentsByIdFdt/{idFDT}" )
1503 public String searchIncidentsByIdFdt( @PathParam( "idFDT" ) int idFDT, @Context HttpServletRequest request )
1504 {
1505 return _signalementRestService.getAnomaliesByIdFDT( idFDT);
1506 }
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519 @GET
1520 @Produces( {
1521 MediaType.APPLICATION_JSON + ";charset=utf-8"
1522 } )
1523 @Path( "getAnomalieByNumber/{number}/{guid}" )
1524 public String getAnomalieByNumber( @PathParam( SignalementRestConstants.PARAMETER_NUMBER ) String number,
1525 @PathParam( SignalementRestConstants.PARAMETER_GUID ) String guid, @Context HttpServletRequest request )
1526 {
1527 return _signalementRestService.getAnomalieByNumber( number, guid );
1528 }
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539 @POST
1540 @Path( "identitystore" )
1541 @Consumes( MediaType.APPLICATION_FORM_URLENCODED )
1542 @Produces( MediaType.APPLICATION_JSON )
1543 public String processIdentityStore( @FormParam( SignalementRestConstants.PARAMETERS_JSON_STREAM ) String strJSONStream,
1544 @Context HttpServletRequest request )
1545 {
1546 IFormatter<ErrorSignalement> formatterJson = new ErrorSignalementFormatterJson( );
1547
1548 if ( StringUtils.isNotBlank( strJSONStream ) )
1549 {
1550
1551 try
1552 {
1553 AppLogService.debug( strJSONStream );
1554 return _signalementRestService.processIdentityStore( strJSONStream );
1555 }
1556 catch( Exception e )
1557 {
1558 AppLogService.error( e.getMessage( ), e );
1559
1560 ErrorSignalementansmarue/modules/rest/pojo/ErrorSignalement.html#ErrorSignalement">ErrorSignalement error = new ErrorSignalement( );
1561 error.setErrorCode( SignalementRestConstants.ERROR_API_REST );
1562 error.setErrorMessage( e.getMessage( ) );
1563
1564 return formatterJson.format( error );
1565 }
1566 }
1567 else
1568 {
1569 ErrorSignalementansmarue/modules/rest/pojo/ErrorSignalement.html#ErrorSignalement">ErrorSignalement error = new ErrorSignalement( );
1570 error.setErrorCode( SignalementRestConstants.ERROR_EMPTY_JSON_REQUEST );
1571 error.setErrorMessage( StringUtils.EMPTY );
1572
1573 return formatterJson.format( error );
1574 }
1575 }
1576 }