001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.service.impl;
016    
017    import com.liferay.portal.DuplicatePasswordPolicyException;
018    import com.liferay.portal.PasswordPolicyNameException;
019    import com.liferay.portal.RequiredPasswordPolicyException;
020    import com.liferay.portal.kernel.cache.ThreadLocalCachable;
021    import com.liferay.portal.kernel.exception.PortalException;
022    import com.liferay.portal.kernel.exception.SystemException;
023    import com.liferay.portal.kernel.util.CharPool;
024    import com.liferay.portal.kernel.util.OrderByComparator;
025    import com.liferay.portal.kernel.util.Validator;
026    import com.liferay.portal.model.Organization;
027    import com.liferay.portal.model.PasswordPolicy;
028    import com.liferay.portal.model.PasswordPolicyRel;
029    import com.liferay.portal.model.ResourceConstants;
030    import com.liferay.portal.model.User;
031    import com.liferay.portal.security.ldap.LDAPSettingsUtil;
032    import com.liferay.portal.service.base.PasswordPolicyLocalServiceBaseImpl;
033    import com.liferay.portal.util.PropsValues;
034    
035    import java.util.Date;
036    import java.util.List;
037    
038    /**
039     * @author Scott Lee
040     */
041    public class PasswordPolicyLocalServiceImpl
042            extends PasswordPolicyLocalServiceBaseImpl {
043    
044            public PasswordPolicy addPasswordPolicy(
045                            long userId, boolean defaultPolicy, String name, String description,
046                            boolean changeable, boolean changeRequired, long minAge,
047                            boolean checkSyntax, boolean allowDictionaryWords,
048                            int minAlphanumeric, int minLength, int minLowerCase,
049                            int minNumbers, int minSymbols, int minUpperCase, boolean history,
050                            int historyCount, boolean expireable, long maxAge, long warningTime,
051                            int graceLimit, boolean lockout, int maxFailure,
052                            long lockoutDuration, long resetFailureCount,
053                            long resetTicketMaxAge)
054                    throws PortalException, SystemException {
055    
056                    // Password policy
057    
058                    User user = userPersistence.findByPrimaryKey(userId);
059                    Date now = new Date();
060    
061                    validate(0, user.getCompanyId(), name);
062    
063                    long passwordPolicyId = counterLocalService.increment();
064    
065                    PasswordPolicy passwordPolicy = passwordPolicyPersistence.create(
066                            passwordPolicyId);
067    
068                    passwordPolicy.setUserId(userId);
069                    passwordPolicy.setCompanyId(user.getCompanyId());
070                    passwordPolicy.setUserName(user.getFullName());
071                    passwordPolicy.setCreateDate(now);
072                    passwordPolicy.setModifiedDate(now);
073                    passwordPolicy.setDefaultPolicy(defaultPolicy);
074                    passwordPolicy.setName(name);
075                    passwordPolicy.setDescription(description);
076                    passwordPolicy.setChangeable(changeable);
077                    passwordPolicy.setChangeRequired(changeRequired);
078                    passwordPolicy.setMinAge(minAge);
079                    passwordPolicy.setCheckSyntax(checkSyntax);
080                    passwordPolicy.setAllowDictionaryWords(allowDictionaryWords);
081                    passwordPolicy.setMinAlphanumeric(minAlphanumeric);
082                    passwordPolicy.setMinLength(minLength);
083                    passwordPolicy.setMinLowerCase(minLowerCase);
084                    passwordPolicy.setMinNumbers(minNumbers);
085                    passwordPolicy.setMinSymbols(minSymbols);
086                    passwordPolicy.setMinUpperCase(minUpperCase);
087                    passwordPolicy.setHistory(history);
088                    passwordPolicy.setHistoryCount(historyCount);
089                    passwordPolicy.setExpireable(expireable);
090                    passwordPolicy.setMaxAge(maxAge);
091                    passwordPolicy.setWarningTime(warningTime);
092                    passwordPolicy.setGraceLimit(graceLimit);
093                    passwordPolicy.setLockout(lockout);
094                    passwordPolicy.setMaxFailure(maxFailure);
095                    passwordPolicy.setLockoutDuration(lockoutDuration);
096                    passwordPolicy.setRequireUnlock(lockoutDuration == 0);
097                    passwordPolicy.setResetFailureCount(resetFailureCount);
098                    passwordPolicy.setResetTicketMaxAge(resetTicketMaxAge);
099    
100                    passwordPolicyPersistence.update(passwordPolicy, false);
101    
102                    // Resources
103    
104                    if (!user.isDefaultUser()) {
105                            resourceLocalService.addResources(
106                                    user.getCompanyId(), 0, userId, PasswordPolicy.class.getName(),
107                                    passwordPolicy.getPasswordPolicyId(), false, false, false);
108                    }
109    
110                    return passwordPolicy;
111            }
112    
113            public void checkDefaultPasswordPolicy(long companyId)
114                    throws PortalException, SystemException {
115    
116                    String defaultPasswordPolicyName =
117                            PropsValues.PASSWORDS_DEFAULT_POLICY_NAME;
118    
119                    PasswordPolicy defaultPasswordPolicy =
120                            passwordPolicyPersistence.fetchByC_N(
121                                    companyId, defaultPasswordPolicyName);
122    
123                    if (defaultPasswordPolicy == null) {
124                            long defaultUserId = userLocalService.getDefaultUserId(companyId);
125    
126                            addPasswordPolicy(
127                                    defaultUserId, true, defaultPasswordPolicyName,
128                                    defaultPasswordPolicyName, true, true, 0, false, true, 0, 6, 0,
129                                    1, 0, 1, false, 6, false, 8640000, 86400, 0, false, 3, 0, 600,
130                                    86400);
131                    }
132            }
133    
134            @Override
135            public PasswordPolicy deletePasswordPolicy(long passwordPolicyId)
136                    throws PortalException, SystemException {
137    
138                    PasswordPolicy passwordPolicy =
139                            passwordPolicyPersistence.findByPrimaryKey(passwordPolicyId);
140    
141                    return deletePasswordPolicy(passwordPolicy);
142            }
143    
144            @Override
145            public PasswordPolicy deletePasswordPolicy(PasswordPolicy passwordPolicy)
146                    throws PortalException, SystemException {
147    
148                    if (passwordPolicy.isDefaultPolicy()) {
149                            throw new RequiredPasswordPolicyException();
150                    }
151    
152                    // Password policy relations
153    
154                    passwordPolicyRelLocalService.deletePasswordPolicyRels(
155                            passwordPolicy.getPasswordPolicyId());
156    
157                    // Resources
158    
159                    resourceLocalService.deleteResource(
160                            passwordPolicy.getCompanyId(), PasswordPolicy.class.getName(),
161                            ResourceConstants.SCOPE_INDIVIDUAL,
162                            passwordPolicy.getPasswordPolicyId());
163    
164                    // Password policy
165    
166                    return passwordPolicyPersistence.remove(passwordPolicy);
167            }
168    
169            public PasswordPolicy getDefaultPasswordPolicy(long companyId)
170                    throws PortalException, SystemException {
171    
172                    if (LDAPSettingsUtil.isPasswordPolicyEnabled(companyId)) {
173                            return null;
174                    }
175    
176                    return passwordPolicyPersistence.findByC_DP(companyId, true);
177            }
178    
179            /**
180             * @deprecated
181             */
182            public PasswordPolicy getPasswordPolicy(
183                            long companyId, long organizationId, long locationId)
184                    throws PortalException, SystemException {
185    
186                    return getPasswordPolicy(
187                            companyId, new long[] {organizationId, locationId});
188            }
189    
190            public PasswordPolicy getPasswordPolicy(
191                            long companyId, long[] organizationIds)
192                    throws PortalException, SystemException {
193    
194                    if (LDAPSettingsUtil.isPasswordPolicyEnabled(companyId)) {
195                            return null;
196                    }
197    
198                    if ((organizationIds == null) || (organizationIds.length == 0)) {
199                            return getDefaultPasswordPolicy(companyId);
200                    }
201    
202                    long classNameId = classNameLocalService.getClassNameId(
203                            Organization.class.getName());
204    
205                    PasswordPolicyRel passwordPolicyRel = null;
206    
207                    for (int i = 0; i < organizationIds.length; i++) {
208                            long organizationId = organizationIds[i];
209    
210                            passwordPolicyRel = passwordPolicyRelPersistence.fetchByC_C(
211                                    classNameId, organizationId);
212    
213                            if (passwordPolicyRel != null) {
214                                    return passwordPolicyPersistence.findByPrimaryKey(
215                                            passwordPolicyRel.getPasswordPolicyId());
216                            }
217                    }
218    
219                    return getDefaultPasswordPolicy(companyId);
220            }
221    
222            @ThreadLocalCachable
223            public PasswordPolicy getPasswordPolicyByUserId(long userId)
224                    throws PortalException, SystemException {
225    
226                    User user = userPersistence.findByPrimaryKey(userId);
227    
228                    if (LDAPSettingsUtil.isPasswordPolicyEnabled(user.getCompanyId())) {
229                            return null;
230                    }
231    
232                    long classNameId = classNameLocalService.getClassNameId(
233                            User.class.getName());
234    
235                    PasswordPolicyRel passwordPolicyRel =
236                            passwordPolicyRelPersistence.fetchByC_C(classNameId, userId);
237    
238                    if (passwordPolicyRel != null) {
239                            return getPasswordPolicy(passwordPolicyRel.getPasswordPolicyId());
240                    }
241                    else {
242                            List<Organization> organizations = userPersistence.getOrganizations(
243                                    userId);
244    
245                            if (organizations.isEmpty()) {
246                                    return passwordPolicyPersistence.findByC_DP(
247                                            user.getCompanyId(), true);
248                            }
249    
250                            long[] organizationIds = new long[organizations.size()];
251    
252                            for (int i = 0; i < organizationIds.length; i++) {
253                                    Organization organization = organizations.get(i);
254    
255                                    organizationIds[i] = organization.getOrganizationId();
256                            }
257    
258                            return getPasswordPolicy(user.getCompanyId(), organizationIds);
259                    }
260            }
261    
262            public List<PasswordPolicy> search(
263                            long companyId, String name, int start, int end,
264                            OrderByComparator obc)
265                    throws SystemException {
266    
267                    return passwordPolicyFinder.findByC_N(companyId, name, start, end, obc);
268            }
269    
270            public int searchCount(long companyId, String name) throws SystemException {
271                    return passwordPolicyFinder.countByC_N(companyId, name);
272            }
273    
274            public PasswordPolicy updatePasswordPolicy(
275                            long passwordPolicyId, String name, String description,
276                            boolean changeable, boolean changeRequired, long minAge,
277                            boolean checkSyntax, boolean allowDictionaryWords,
278                            int minAlphanumeric, int minLength, int minLowerCase,
279                            int minNumbers, int minSymbols, int minUpperCase, boolean history,
280                            int historyCount, boolean expireable, long maxAge, long warningTime,
281                            int graceLimit, boolean lockout, int maxFailure,
282                            long lockoutDuration, long resetFailureCount,
283                            long resetTicketMaxAge)
284                    throws PortalException, SystemException {
285    
286                    Date now = new Date();
287    
288                    PasswordPolicy passwordPolicy =
289                            passwordPolicyPersistence.findByPrimaryKey(passwordPolicyId);
290    
291                    if (!passwordPolicy.getDefaultPolicy()) {
292                            validate(passwordPolicyId, passwordPolicy.getCompanyId(), name);
293    
294                            passwordPolicy.setName(name);
295                    }
296    
297                    passwordPolicy.setModifiedDate(now);
298                    passwordPolicy.setDescription(description);
299                    passwordPolicy.setChangeable(changeable);
300                    passwordPolicy.setChangeRequired(changeRequired);
301                    passwordPolicy.setMinAge(minAge);
302                    passwordPolicy.setCheckSyntax(checkSyntax);
303                    passwordPolicy.setAllowDictionaryWords(allowDictionaryWords);
304                    passwordPolicy.setMinAlphanumeric(minAlphanumeric);
305                    passwordPolicy.setMinLength(minLength);
306                    passwordPolicy.setMinLowerCase(minLowerCase);
307                    passwordPolicy.setMinNumbers(minNumbers);
308                    passwordPolicy.setMinSymbols(minSymbols);
309                    passwordPolicy.setMinUpperCase(minUpperCase);
310                    passwordPolicy.setHistory(history);
311                    passwordPolicy.setHistoryCount(historyCount);
312                    passwordPolicy.setExpireable(expireable);
313                    passwordPolicy.setMaxAge(maxAge);
314                    passwordPolicy.setWarningTime(warningTime);
315                    passwordPolicy.setGraceLimit(graceLimit);
316                    passwordPolicy.setLockout(lockout);
317                    passwordPolicy.setMaxFailure(maxFailure);
318                    passwordPolicy.setLockoutDuration(lockoutDuration);
319                    passwordPolicy.setRequireUnlock(lockoutDuration == 0);
320                    passwordPolicy.setResetFailureCount(resetFailureCount);
321                    passwordPolicy.setResetTicketMaxAge(resetTicketMaxAge);
322    
323                    passwordPolicyPersistence.update(passwordPolicy, false);
324    
325                    return passwordPolicy;
326            }
327    
328            protected void validate(long passwordPolicyId, long companyId, String name)
329                    throws PortalException, SystemException {
330    
331                    if (Validator.isNull(name) || Validator.isNumber(name) ||
332                            (name.indexOf(CharPool.COMMA) != -1) ||
333                            (name.indexOf(CharPool.STAR) != -1)) {
334    
335                            throw new PasswordPolicyNameException();
336                    }
337    
338                    PasswordPolicy passwordPolicy = passwordPolicyPersistence.fetchByC_N(
339                            companyId, name);
340    
341                    if (passwordPolicy != null) {
342                            if ((passwordPolicyId <= 0) ||
343                                    (passwordPolicy.getPasswordPolicyId() != passwordPolicyId)) {
344    
345                                    throw new DuplicatePasswordPolicyException();
346                            }
347                    }
348            }
349    
350    }