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.identitystore.modules.taskstack.provider;
35
36 import fr.paris.lutece.plugins.identitystore.business.attribute.AttributeKey;
37 import fr.paris.lutece.plugins.identitystore.business.identity.Identity;
38 import fr.paris.lutece.plugins.identitystore.business.identity.IdentityHome;
39 import fr.paris.lutece.plugins.identitystore.business.referentiel.RefAttributeCertificationLevel;
40 import fr.paris.lutece.plugins.identitystore.service.attribute.IdentityAttributeService;
41 import fr.paris.lutece.plugins.identitystore.service.attribute.IdentityAttributeValidationService;
42 import fr.paris.lutece.plugins.identitystore.service.contract.AttributeCertificationDefinitionService;
43 import fr.paris.lutece.plugins.identitystore.service.identity.IdentityAttributeNotFoundException;
44 import fr.paris.lutece.plugins.identitystore.v3.web.rs.DtoConverter;
45 import fr.paris.lutece.plugins.identitystore.v3.web.rs.dto.common.AttributeDto;
46 import fr.paris.lutece.plugins.identitystore.v3.web.rs.dto.common.IdentityDto;
47 import fr.paris.lutece.plugins.identitystore.v3.web.rs.util.Constants;
48 import fr.paris.lutece.plugins.taskstack.exception.TaskValidationException;
49 import fr.paris.lutece.plugins.taskstack.service.ITaskManagement;
50 import fr.paris.lutece.portal.service.util.AppPropertiesService;
51
52 import java.util.ArrayList;
53 import java.util.List;
54 import java.util.stream.Collectors;
55
56 public abstract class AbstractTaskManagement implements ITaskManagement
57 {
58 protected IdentityDto validateAndGetIdentity( final String cuid ) throws TaskValidationException
59 {
60 final Identity identity = IdentityHome.findByCustomerId( cuid );
61 if ( identity == null )
62 {
63 throw new TaskValidationException( "No identity was found for the provided CUID" );
64 }
65 if ( identity.isDeleted( ) )
66 {
67 throw new TaskValidationException( "The identity is deleted" );
68 }
69 if ( identity.isMerged( ) )
70 {
71 throw new TaskValidationException( "The identity is merged" );
72 }
73
74 return DtoConverter.convertIdentityToDto( identity );
75 }
76
77 protected void validateEmail( final IdentityDto identityDto, final boolean checkCertification ) throws TaskValidationException
78 {
79 final AttributeDto emailAttr = identityDto.getAttributes( ).stream( ).filter( a -> a.getKey( ).equals( Constants.PARAM_EMAIL ) ).findFirst( )
80 .orElseThrow( ( ) -> new TaskValidationException( "The identity does not have an email attribute" ) );
81 try
82 {
83 if ( !IdentityAttributeValidationService.instance( ).validateAttribute( Constants.PARAM_EMAIL, emailAttr.getValue( ) ) )
84 {
85 throw new TaskValidationException( "The identity email has an invalid value format" );
86 }
87 }
88 catch( final IdentityAttributeNotFoundException e )
89 {
90 throw new TaskValidationException( e.getMessage( ), e );
91 }
92 if ( checkCertification )
93 {
94 if ( emailAttr.getCertificationLevel( ) != null && emailAttr.getCertificationLevel( ) > 100 )
95 {
96 throw new TaskValidationException( "The identity email has already been validated" );
97 }
98 }
99 }
100
101 protected void validateAccountRequirement( final IdentityDto identityDto ) throws TaskValidationException
102 {
103 this.validateEmail( identityDto, false );
104 if ( identityDto.isMonParisActive( ) )
105 {
106 throw new TaskValidationException( "The identity is already connected" );
107 }
108 this.validateIdentityCertification( identityDto );
109 }
110
111
112 private void validateIdentityCertification( final IdentityDto identityDto ) throws TaskValidationException
113 {
114 final String minCertificationCode = AppPropertiesService.getProperty( "task.account.creation.minimum.certification" );
115 final List<String> pivotKeys = IdentityAttributeService.instance( ).getPivotAttributeKeys( ).stream( ).map( AttributeKey::getKeyName )
116 .collect( Collectors.toList( ) );
117 final List<AttributeDto> pivotAttributes = identityDto.getAttributes( ).stream( ).filter( a -> pivotKeys.contains( a.getKey( ) ) )
118 .collect( Collectors.toList( ) );
119
120
121 if ( pivotAttributes.size( ) == pivotKeys.size( ) )
122 {
123 this.validateAttributesCertification( pivotAttributes, minCertificationCode );
124 }
125
126
127 else
128 if ( pivotAttributes.size( ) == pivotKeys.size( ) - 1
129 && pivotAttributes.stream( ).map( AttributeDto::getKey ).noneMatch( s -> s.equals( Constants.PARAM_BIRTH_PLACE_CODE ) )
130 && pivotAttributes.stream( ).anyMatch( attributeDto -> attributeDto.getKey( ).equals( Constants.PARAM_BIRTH_COUNTRY_CODE )
131 && !attributeDto.getValue( ).equals( "99100" ) ) )
132 {
133 this.validateAttributesCertification( pivotAttributes, minCertificationCode );
134 }
135
136
137 else
138 {
139 throw new TaskValidationException( "The identity has missing pivot attributes and cannot be connected" );
140 }
141 }
142
143 private void validateAttributesCertification( final List<AttributeDto> pivotAttributes, final String minCertificationCode ) throws TaskValidationException
144 {
145 final List<String> errors = new ArrayList<>( );
146 for ( final AttributeDto attributeDto : pivotAttributes )
147 {
148 final RefAttributeCertificationLevel certificationLevel = AttributeCertificationDefinitionService.instance( ).get( minCertificationCode,
149 attributeDto.getKey( ) );
150 final Integer minRequiredLevel = Integer.valueOf( certificationLevel.getRefCertificationLevel( ).getLevel( ) );
151 if ( attributeDto.getCertificationLevel( ) < minRequiredLevel )
152 {
153 errors.add( "[attribute-key=" + attributeDto.getKey( ) + "][attribute-certification-level=" + attributeDto.getCertificationLevel( )
154 + "][expected-level=" + minRequiredLevel + "]" );
155 }
156 }
157 if ( !errors.isEmpty( ) )
158 {
159 final StringBuilder error = new StringBuilder( "Some errors occurred during pivot attributes validation. The minimum certification processus is " )
160 .append( minCertificationCode ).append( "." );
161 errors.forEach( error::append );
162 throw new TaskValidationException( error.toString( ) );
163 }
164 }
165
166 }