001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
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);
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,
129                                    PropsValues.PASSWORDS_DEFAULT_POLICY_CHANGEABLE,
130                                    PropsValues.PASSWORDS_DEFAULT_POLICY_CHANGE_REQUIRED,
131                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MIN_AGE,
132                                    PropsValues.PASSWORDS_DEFAULT_POLICY_CHECK_SYNTAX,
133                                    PropsValues.PASSWORDS_DEFAULT_POLICY_ALLOW_DICTIONARY_WORDS,
134                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MIN_ALPHANUMERIC,
135                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MIN_LENGTH,
136                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MIN_LOWERCASE,
137                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MIN_NUMBERS,
138                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MIN_SYMBOLS,
139                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MIN_UPPERCASE,
140                                    PropsValues.PASSWORDS_DEFAULT_POLICY_HISTORY,
141                                    PropsValues.PASSWORDS_DEFAULT_POLICY_HISTORY_COUNT,
142                                    PropsValues.PASSWORDS_DEFAULT_POLICY_EXPIREABLE,
143                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MAX_AGE,
144                                    PropsValues.PASSWORDS_DEFAULT_POLICY_WARNING_TIME,
145                                    PropsValues.PASSWORDS_DEFAULT_POLICY_GRACE_LIMIT,
146                                    PropsValues.PASSWORDS_DEFAULT_POLICY_LOCKOUT,
147                                    PropsValues.PASSWORDS_DEFAULT_POLICY_MAX_FAILURE,
148                                    PropsValues.PASSWORDS_DEFAULT_POLICY_LOCKOUT_DURATION,
149                                    PropsValues.PASSWORDS_DEFAULT_POLICY_RESET_FAILURE_COUNT,
150                                    PropsValues.PASSWORDS_DEFAULT_POLICY_RESET_TICKET_MAX_AGE);
151                    }
152            }
153    
154            @Override
155            public PasswordPolicy deletePasswordPolicy(long passwordPolicyId)
156                    throws PortalException, SystemException {
157    
158                    PasswordPolicy passwordPolicy =
159                            passwordPolicyPersistence.findByPrimaryKey(passwordPolicyId);
160    
161                    return deletePasswordPolicy(passwordPolicy);
162            }
163    
164            @Override
165            public PasswordPolicy deletePasswordPolicy(PasswordPolicy passwordPolicy)
166                    throws PortalException, SystemException {
167    
168                    if (passwordPolicy.isDefaultPolicy()) {
169                            throw new RequiredPasswordPolicyException();
170                    }
171    
172                    // Password policy relations
173    
174                    passwordPolicyRelLocalService.deletePasswordPolicyRels(
175                            passwordPolicy.getPasswordPolicyId());
176    
177                    // Resources
178    
179                    resourceLocalService.deleteResource(
180                            passwordPolicy.getCompanyId(), PasswordPolicy.class.getName(),
181                            ResourceConstants.SCOPE_INDIVIDUAL,
182                            passwordPolicy.getPasswordPolicyId());
183    
184                    // Password policy
185    
186                    return passwordPolicyPersistence.remove(passwordPolicy);
187            }
188    
189            public PasswordPolicy getDefaultPasswordPolicy(long companyId)
190                    throws PortalException, SystemException {
191    
192                    if (LDAPSettingsUtil.isPasswordPolicyEnabled(companyId)) {
193                            return null;
194                    }
195    
196                    return passwordPolicyPersistence.findByC_DP(companyId, true);
197            }
198    
199            /**
200             * @deprecated
201             */
202            public PasswordPolicy getPasswordPolicy(
203                            long companyId, long organizationId, long locationId)
204                    throws PortalException, SystemException {
205    
206                    return getPasswordPolicy(
207                            companyId, new long[] {organizationId, locationId});
208            }
209    
210            public PasswordPolicy getPasswordPolicy(
211                            long companyId, long[] organizationIds)
212                    throws PortalException, SystemException {
213    
214                    if (LDAPSettingsUtil.isPasswordPolicyEnabled(companyId)) {
215                            return null;
216                    }
217    
218                    if ((organizationIds == null) || (organizationIds.length == 0)) {
219                            return getDefaultPasswordPolicy(companyId);
220                    }
221    
222                    long classNameId = classNameLocalService.getClassNameId(
223                            Organization.class.getName());
224    
225                    PasswordPolicyRel passwordPolicyRel = null;
226    
227                    for (int i = 0; i < organizationIds.length; i++) {
228                            long organizationId = organizationIds[i];
229    
230                            passwordPolicyRel = passwordPolicyRelPersistence.fetchByC_C(
231                                    classNameId, organizationId);
232    
233                            if (passwordPolicyRel != null) {
234                                    return passwordPolicyPersistence.findByPrimaryKey(
235                                            passwordPolicyRel.getPasswordPolicyId());
236                            }
237                    }
238    
239                    return getDefaultPasswordPolicy(companyId);
240            }
241    
242            @ThreadLocalCachable
243            public PasswordPolicy getPasswordPolicyByUserId(long userId)
244                    throws PortalException, SystemException {
245    
246                    User user = userPersistence.findByPrimaryKey(userId);
247    
248                    if (LDAPSettingsUtil.isPasswordPolicyEnabled(user.getCompanyId())) {
249                            return null;
250                    }
251    
252                    long classNameId = classNameLocalService.getClassNameId(
253                            User.class.getName());
254    
255                    PasswordPolicyRel passwordPolicyRel =
256                            passwordPolicyRelPersistence.fetchByC_C(classNameId, userId);
257    
258                    if (passwordPolicyRel != null) {
259                            return getPasswordPolicy(passwordPolicyRel.getPasswordPolicyId());
260                    }
261                    else {
262                            List<Organization> organizations = userPersistence.getOrganizations(
263                                    userId);
264    
265                            if (organizations.isEmpty()) {
266                                    return passwordPolicyPersistence.findByC_DP(
267                                            user.getCompanyId(), true);
268                            }
269    
270                            long[] organizationIds = new long[organizations.size()];
271    
272                            for (int i = 0; i < organizationIds.length; i++) {
273                                    Organization organization = organizations.get(i);
274    
275                                    organizationIds[i] = organization.getOrganizationId();
276                            }
277    
278                            return getPasswordPolicy(user.getCompanyId(), organizationIds);
279                    }
280            }
281    
282            public List<PasswordPolicy> search(
283                            long companyId, String name, int start, int end,
284                            OrderByComparator obc)
285                    throws SystemException {
286    
287                    return passwordPolicyFinder.findByC_N(companyId, name, start, end, obc);
288            }
289    
290            public int searchCount(long companyId, String name) throws SystemException {
291                    return passwordPolicyFinder.countByC_N(companyId, name);
292            }
293    
294            public PasswordPolicy updatePasswordPolicy(
295                            long passwordPolicyId, String name, String description,
296                            boolean changeable, boolean changeRequired, long minAge,
297                            boolean checkSyntax, boolean allowDictionaryWords,
298                            int minAlphanumeric, int minLength, int minLowerCase,
299                            int minNumbers, int minSymbols, int minUpperCase, boolean history,
300                            int historyCount, boolean expireable, long maxAge, long warningTime,
301                            int graceLimit, boolean lockout, int maxFailure,
302                            long lockoutDuration, long resetFailureCount,
303                            long resetTicketMaxAge)
304                    throws PortalException, SystemException {
305    
306                    Date now = new Date();
307    
308                    PasswordPolicy passwordPolicy =
309                            passwordPolicyPersistence.findByPrimaryKey(passwordPolicyId);
310    
311                    if (!passwordPolicy.getDefaultPolicy()) {
312                            validate(passwordPolicyId, passwordPolicy.getCompanyId(), name);
313    
314                            passwordPolicy.setName(name);
315                    }
316    
317                    passwordPolicy.setModifiedDate(now);
318                    passwordPolicy.setDescription(description);
319                    passwordPolicy.setChangeable(changeable);
320                    passwordPolicy.setChangeRequired(changeRequired);
321                    passwordPolicy.setMinAge(minAge);
322                    passwordPolicy.setCheckSyntax(checkSyntax);
323                    passwordPolicy.setAllowDictionaryWords(allowDictionaryWords);
324                    passwordPolicy.setMinAlphanumeric(minAlphanumeric);
325                    passwordPolicy.setMinLength(minLength);
326                    passwordPolicy.setMinLowerCase(minLowerCase);
327                    passwordPolicy.setMinNumbers(minNumbers);
328                    passwordPolicy.setMinSymbols(minSymbols);
329                    passwordPolicy.setMinUpperCase(minUpperCase);
330                    passwordPolicy.setHistory(history);
331                    passwordPolicy.setHistoryCount(historyCount);
332                    passwordPolicy.setExpireable(expireable);
333                    passwordPolicy.setMaxAge(maxAge);
334                    passwordPolicy.setWarningTime(warningTime);
335                    passwordPolicy.setGraceLimit(graceLimit);
336                    passwordPolicy.setLockout(lockout);
337                    passwordPolicy.setMaxFailure(maxFailure);
338                    passwordPolicy.setLockoutDuration(lockoutDuration);
339                    passwordPolicy.setRequireUnlock(lockoutDuration == 0);
340                    passwordPolicy.setResetFailureCount(resetFailureCount);
341                    passwordPolicy.setResetTicketMaxAge(resetTicketMaxAge);
342    
343                    passwordPolicyPersistence.update(passwordPolicy);
344    
345                    return passwordPolicy;
346            }
347    
348            protected void validate(long passwordPolicyId, long companyId, String name)
349                    throws PortalException, SystemException {
350    
351                    if (Validator.isNull(name) || Validator.isNumber(name) ||
352                            (name.indexOf(CharPool.COMMA) != -1) ||
353                            (name.indexOf(CharPool.STAR) != -1)) {
354    
355                            throw new PasswordPolicyNameException();
356                    }
357    
358                    PasswordPolicy passwordPolicy = passwordPolicyPersistence.fetchByC_N(
359                            companyId, name);
360    
361                    if (passwordPolicy != null) {
362                            if ((passwordPolicyId <= 0) ||
363                                    (passwordPolicy.getPasswordPolicyId() != passwordPolicyId)) {
364    
365                                    throw new DuplicatePasswordPolicyException();
366                            }
367                    }
368            }
369    
370    }