Map<String, Object> model = getModel(  );
        
        LuteceUser user = SecurityService.getInstance( ).getRegisteredUser(request);
   	 
   	 
 	   
    	HashMap<String,Alert> userAlertMap=new HashMap<>();
    	
    	if(user!=null)
   	 	{
    		List<Alert> listUserAlert=ParisConnectService.getInstance().getUserAlerts(user.getName());
        	
        	
	    	if(listUserAlert != null)
	    	{
	    		for(Alert alertUser:listUserAlert)
		    	{
	    			userAlertMap.put(alertUser.getIdPc(),alertUser);
		    	}
	    	}
   	 	}
    	
    	List<Alert> listAlert=ParisConnectService.getInstance().getAlerts();
    	HashMap<String ,List<Alert>> mapCategoryListAlert=new HashMap<>();
    	mapCategoryListAlert.put(KEY_NO_CATEGORY, new ArrayList<Alert>());
    
    	List<Category> listCategory=CategoryHome.getCategorysList();
    	
     
	 	if(listCategory!=null && listCategory.size() > 0)
		{
	 		HashMap<String, Category> mapCategory=new HashMap<>();
	 		for(Category category:listCategory)
	 		{
	 			mapCategory.put(category.getCode(), category);
	 		}
	 		model.put( MARK_CATEGORY_MAP,mapCategory);
		}
	 	
	 	for(Alert alert:listAlert)
	 	{
	 		
	 		if(alert.getCategory()!=null)
	 		{
	 			if(!mapCategoryListAlert.containsKey(alert.getCategory()))
	 			{
	 				mapCategoryListAlert.put(alert.getCategory(), new ArrayList<Alert>());
	 			}
	 			mapCategoryListAlert.get(alert.getCategory()).add(alert);
	 		}
	 		else
	 		{
	 			mapCategoryListAlert.get(KEY_NO_CATEGORY).add(alert);
	 		}
	 		
	 	}

     
     

       model.put( MARK_USER_ALERT_HASH, userAlertMap);
       model.put( MARK_ALERT_LIST, listAlert);
       model.put( MARK_CATEGORY_LIST,listCategory );
       model.put(MARK_CATEGORY_LIST_ALERT_HASH,mapCategoryListAlert);

        daoUtil.setInt( 1 , nKey );
        daoUtil.executeQuery( );
        Newsletter newsletter = null;

        if ( daoUtil.next( ) )
        {
            newsletter = new Newsletter();
            int nIndex = 1;
            
            newsletter.setId( daoUtil.getInt( nIndex++ ) );
            newsletter.setTitle( daoUtil.getString( nIndex++ ) );
            newsletter.setDescription( daoUtil.getString( nIndex++ ) );
            newsletter.setEnabled( daoUtil.getBoolean( nIndex++ ) );
            
            if(daoUtil.getObject(nIndex)!=null)
            {
            	File img=new File();
            	img.setIdFile(daoUtil.getInt( nIndex++));
            	newsletter.setPicture( img );
            }
            else
            {
            	 nIndex++;
            }
        
         
            newsletter.setNbSuscribed( daoUtil.getInt( nIndex++ ) );
            newsletter.setLinkRequirement( daoUtil.getString( nIndex++ ) );
            newsletter.setCategory( daoUtil.getString( nIndex++ ) );
            newsletter.setCode(daoUtil.getString( nIndex++ ));
            newsletter.setLinkLastNumber(daoUtil.getString( nIndex++ ));
        }

        daoUtil.free( );
        return newsletter;
    }
    
    /**
     * {@inheritDoc }
     */
    @Override
    public Newsletter loadByCode( String strCode, Plugin plugin )

        newsletter.setId( newPrimaryKey( plugin ) );
        int nIndex = 1;
        
        daoUtil.setInt( nIndex++ , newsletter.getId( ) );
        daoUtil.setString( nIndex++ , newsletter.getTitle( ) );
        daoUtil.setString( nIndex++ , newsletter.getDescription( ) );
        daoUtil.setBoolean( nIndex++ , newsletter.getEnabled( ) );
        if(newsletter.getPicture() != null)
        {
        	daoUtil.setInt( nIndex++ , newsletter.getPicture().getIdFile() );
        }
        else
        {
        	daoUtil.setIntNull( nIndex++ );
        }
        daoUtil.setInt( nIndex++ , newsletter.getNbSuscribed( ) );
        daoUtil.setString( nIndex++ , newsletter.getLinkRequirement( ) );
        daoUtil.setString( nIndex++ , newsletter.getCategory( ) );
        daoUtil.setString( nIndex++ , newsletter.getCode());
        daoUtil.setString( nIndex++ , newsletter.getLinkLastNumber());
    
        
        daoUtil.executeUpdate( );

        if (  StringUtils.isEmpty(strId))
        {
            _logger.error( Constants.ERROR_BAD_REQUEST_EMPTY_PARAMETER );
            return Response.status( Response.Status.BAD_REQUEST )
                    .entity( JsonUtil.buildJsonResponse( new ErrorJsonResponse( Response.Status.BAD_REQUEST.name( ), Constants.ERROR_BAD_REQUEST_EMPTY_PARAMETER ) ) )
                    .build( );
        }
        
        LuteceUser user=null;
		try {
			user = SecurityService.getInstance( ).getRemoteUser(request);
		} catch (UserNotSignedException e) {
				
		}
   	 
   	 
	   	 if(user==null)
	   	 {
	   		_logger.error( Constants.ERROR_USER_NOT_AUTHENTICATED );
            return Response.status( Response.Status.UNAUTHORIZED )
                    .entity( JsonUtil.buildJsonResponse( new ErrorJsonResponse( Constants.ERROR_USER_NOT_AUTHENTICATED, Constants.ERROR_USER_NOT_AUTHENTICATED ) ) )
                    .build( );
  
	   	 }
	   	 else
	   	 {
     
	    	String strError=ParisConnectService.getInstance().subscribeAlert(user.getName(), strId);

        if (  StringUtils.isEmpty(strId))
        {
            _logger.error( Constants.ERROR_BAD_REQUEST_EMPTY_PARAMETER );
            return Response.status( Response.Status.BAD_REQUEST )
                    .entity( JsonUtil.buildJsonResponse( new ErrorJsonResponse( Response.Status.BAD_REQUEST.name( ), Constants.ERROR_BAD_REQUEST_EMPTY_PARAMETER ) ) )
                    .build( );
        }
        
        LuteceUser user=null;
		try {
			user = SecurityService.getInstance( ).getRemoteUser(request);
		} catch (UserNotSignedException e) {
				
		}
   	 
   	 
	   	 if(user==null)
	   	 {
	   		_logger.error( Constants.ERROR_USER_NOT_AUTHENTICATED );
            return Response.status( Response.Status.UNAUTHORIZED )
                    .entity( JsonUtil.buildJsonResponse( new ErrorJsonResponse( Constants.ERROR_USER_NOT_AUTHENTICATED, Constants.ERROR_USER_NOT_AUTHENTICATED ) ) )
                    .build( );
  
	   	 }
	   	 else
	   	 {

        if(fileItem!=null)
        {
        
	        byte[] bytes = fileItem.get(  );
	        if ( bytes != null )
	        {
	        	File file = new File();
	        	file.setTitle(fileItem.getName());
	        	file.setSize((fileItem.getSize() < Integer.MAX_VALUE) ? (int) fileItem
	                .getSize() : Integer.MAX_VALUE);
	        	file.setMimeType(FileSystemUtil.getMIMEType(file.getTitle()));
	
		        PhysicalFile physicalFile = new PhysicalFile();
		        physicalFile.setValue(fileItem.get());
		        file.setPhysicalFile(physicalFile);
		        
		        _newsletter.setPicture(file);
		        
	        }
        
        }
        
        NewsletterHome.create( _newsletter );

            strResponse = httpAccess.doPost( url.getUrl(  ), mapParameters );
            if(!StringUtils.isEmpty(strResponse))
            {
            	strResponse=strResponse.trim();
            }
            if ( _bDebug )
            {
                _logger.debug( "API call : " + getCallUrl( url.getUrl(  ), mapParameters ) );
            }
        }
        catch ( HttpAccessException ex )
        {
            _logger.error( "Error calling method '" + strMethod + " - " + ex.getMessage(  ), ex );
        }

        if ( !StringUtils.isEmpty(strResponse) )
        {
            boolean bJSONArray = strResponse.startsWith( "[{" );

            // Responses are not always in JSON format and Array should not be checked for errors
            if ( bJSON && !bJSONArray )
            {
                checkJSONforErrors( strResponse );
            }
        }

        return strResponse;
    }

    public static String getNewsletterTemplate ( HttpServletRequest request )
    {
        Map<String, Object> model = new HashMap<String, Object>(  );
        Locale locale = ( request == null ) ? null : request.getLocale(  );
        
        
        LuteceUser user =  SecurityService.getInstance(  ).getRegisteredUser( request );

        if ( user != null )
        {      
            model.put( MARK_USER_EMAIL, user.getEmail() );            
        }                         
        model.put(SecurityTokenService.MARK_TOKEN,request!=null?SecurityTokenService.getInstance().getToken(request, TOKEN_DO_SUBSCRIBE_ALERT):EMPTY_STRING);
        HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_NEWSLETTER_INCLUDE, locale, model );

	    	String strError=ParisConnectService.getInstance().subscribeAlert(user.getName(), strId);
	    	if(StringUtils.isNotEmpty(strError))
	    	{
	    		   return Response.status(  Response.Status.BAD_REQUEST )
	                       .entity( JsonUtil.buildJsonResponse( new ErrorJsonResponse(strError,strError) ) )
	                       .build( );
	     
	    		
	    	}
	   	 	
	   	 }
	    	
	   	 return Response.status( Response.Status.OK )
                .entity( JsonUtil.buildJsonResponse( new JsonResponse(StringUtils.EMPTY) {
				}) )
                .build( );
    }
    
    
    /**
     * subscribe Alert
     * @param nVersion the API version
     * @return subscribe Alert
     */
    @POST
    @Path( Constants.ID_PATH +Constants.UNSUBSCRIBE_PATH)
    @Produces( MediaType.APPLICATION_JSON )
    public Response unSubscribeAlert(

        daoUtil.setInt( 1 , nKey );
        daoUtil.executeQuery( );
        Alert alert = null;

        if ( daoUtil.next( ) )
        {
            alert = new Alert();
            int nIndex = 1;
            
            alert.setId( daoUtil.getInt( nIndex++ ) );
            alert.setTitle( daoUtil.getString( nIndex++ ) );
            alert.setDescription( daoUtil.getString( nIndex++ ) );
            alert.setCategory( daoUtil.getString( nIndex++ ) );
            alert.setIdPc( daoUtil.getString( nIndex++ ));
        }

        daoUtil.free( );
        return alert;
    }
    
    /**
     * {@inheritDoc }
     */
    @Override
    public Alert loadByIdPc( String strIdPc, Plugin plugin )