001    /**
002     * Copyright (c) 2000-present 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.portlet.passwordpoliciesadmin.action;
016    
017    import com.liferay.portal.DuplicatePasswordPolicyException;
018    import com.liferay.portal.NoSuchPasswordPolicyException;
019    import com.liferay.portal.PasswordPolicyNameException;
020    import com.liferay.portal.RequiredPasswordPolicyException;
021    import com.liferay.portal.kernel.servlet.SessionErrors;
022    import com.liferay.portal.kernel.util.Constants;
023    import com.liferay.portal.kernel.util.ParamUtil;
024    import com.liferay.portal.kernel.util.Validator;
025    import com.liferay.portal.model.PasswordPolicy;
026    import com.liferay.portal.security.auth.PrincipalException;
027    import com.liferay.portal.service.PasswordPolicyServiceUtil;
028    import com.liferay.portal.service.ServiceContext;
029    import com.liferay.portal.service.ServiceContextFactory;
030    import com.liferay.portal.struts.PortletAction;
031    import com.liferay.portal.util.PortalUtil;
032    
033    import javax.portlet.ActionRequest;
034    import javax.portlet.ActionResponse;
035    import javax.portlet.PortletConfig;
036    import javax.portlet.RenderRequest;
037    import javax.portlet.RenderResponse;
038    
039    import org.apache.struts.action.ActionForm;
040    import org.apache.struts.action.ActionForward;
041    import org.apache.struts.action.ActionMapping;
042    
043    /**
044     * @author Scott Lee
045     */
046    public class EditPasswordPolicyAction extends PortletAction {
047    
048            @Override
049            public void processAction(
050                            ActionMapping actionMapping, ActionForm actionForm,
051                            PortletConfig portletConfig, ActionRequest actionRequest,
052                            ActionResponse actionResponse)
053                    throws Exception {
054    
055                    String cmd = ParamUtil.getString(actionRequest, Constants.CMD);
056    
057                    try {
058                            if (cmd.equals(Constants.ADD) || cmd.equals(Constants.UPDATE)) {
059                                    updatePasswordPolicy(actionRequest);
060                            }
061                            else if (cmd.equals(Constants.DELETE)) {
062                                    deletePasswordPolicy(actionRequest);
063                            }
064    
065                            sendRedirect(actionRequest, actionResponse);
066                    }
067                    catch (Exception e) {
068                            if (e instanceof PrincipalException) {
069                                    SessionErrors.add(actionRequest, e.getClass());
070    
071                                    setForward(
072                                            actionRequest, "portlet.password_policies_admin.error");
073                            }
074                            else if (e instanceof DuplicatePasswordPolicyException ||
075                                             e instanceof PasswordPolicyNameException ||
076                                             e instanceof NoSuchPasswordPolicyException ||
077                                             e instanceof RequiredPasswordPolicyException) {
078    
079                                    SessionErrors.add(actionRequest, e.getClass());
080    
081                                    if (cmd.equals(Constants.DELETE)) {
082                                            String redirect = PortalUtil.escapeRedirect(
083                                                    ParamUtil.getString(actionRequest, "redirect"));
084    
085                                            if (Validator.isNotNull(redirect)) {
086                                                    actionResponse.sendRedirect(redirect);
087                                            }
088                                    }
089                            }
090                            else {
091                                    throw e;
092                            }
093                    }
094            }
095    
096            @Override
097            public ActionForward render(
098                            ActionMapping actionMapping, ActionForm actionForm,
099                            PortletConfig portletConfig, RenderRequest renderRequest,
100                            RenderResponse renderResponse)
101                    throws Exception {
102    
103                    try {
104                            ActionUtil.getPasswordPolicy(renderRequest);
105                    }
106                    catch (Exception e) {
107                            if (e instanceof NoSuchPasswordPolicyException ||
108                                    e instanceof PrincipalException) {
109    
110                                    SessionErrors.add(renderRequest, e.getClass());
111    
112                                    return actionMapping.findForward(
113                                            "portlet.password_policies_admin.error");
114                            }
115                            else {
116                                    throw e;
117                            }
118                    }
119    
120                    return actionMapping.findForward(
121                            getForward(
122                                    renderRequest,
123                                    "portlet.password_policies_admin.edit_password_policy"));
124            }
125    
126            protected void deletePasswordPolicy(ActionRequest actionRequest)
127                    throws Exception {
128    
129                    long passwordPolicyId = ParamUtil.getLong(
130                            actionRequest, "passwordPolicyId");
131    
132                    PasswordPolicyServiceUtil.deletePasswordPolicy(passwordPolicyId);
133            }
134    
135            protected void updatePasswordPolicy(ActionRequest actionRequest)
136                    throws Exception {
137    
138                    long passwordPolicyId = ParamUtil.getLong(
139                            actionRequest, "passwordPolicyId");
140    
141                    String name = ParamUtil.getString(actionRequest, "name");
142                    String description = ParamUtil.getString(actionRequest, "description");
143                    boolean changeable = ParamUtil.getBoolean(actionRequest, "changeable");
144    
145                    boolean changeRequired = false;
146                    long minAge = 0;
147    
148                    if (changeable) {
149                            changeRequired = ParamUtil.getBoolean(
150                                    actionRequest, "changeRequired");
151                            minAge = ParamUtil.getLong(actionRequest, "minAge");
152                    }
153    
154                    boolean checkSyntax = ParamUtil.getBoolean(
155                            actionRequest, "checkSyntax");
156                    boolean allowDictionaryWords = ParamUtil.getBoolean(
157                            actionRequest, "allowDictionaryWords");
158                    int minAlphanumeric = ParamUtil.getInteger(
159                            actionRequest, "minAlphanumeric");
160                    int minLength = ParamUtil.getInteger(actionRequest, "minLength");
161                    int minLowerCase = ParamUtil.getInteger(actionRequest, "minLowerCase");
162                    int minNumbers = ParamUtil.getInteger(actionRequest, "minNumbers");
163                    int minSymbols = ParamUtil.getInteger(actionRequest, "minSymbols");
164                    int minUpperCase = ParamUtil.getInteger(actionRequest, "minUpperCase");
165                    String regex = ParamUtil.getString(actionRequest, "regex");
166                    boolean history = ParamUtil.getBoolean(actionRequest, "history");
167                    int historyCount = ParamUtil.getInteger(actionRequest, "historyCount");
168                    boolean expireable = ParamUtil.getBoolean(actionRequest, "expireable");
169                    long maxAge = ParamUtil.getLong(actionRequest, "maxAge");
170                    long warningTime = ParamUtil.getLong(actionRequest, "warningTime");
171                    int graceLimit = ParamUtil.getInteger(actionRequest, "graceLimit");
172                    boolean lockout = ParamUtil.getBoolean(actionRequest, "lockout");
173                    int maxFailure = ParamUtil.getInteger(actionRequest, "maxFailure");
174                    long lockoutDuration = ParamUtil.getLong(
175                            actionRequest, "lockoutDuration");
176                    long resetFailureCount = ParamUtil.getLong(
177                            actionRequest, "resetFailureCount");
178                    long resetTicketMaxAge = ParamUtil.getLong(
179                            actionRequest, "resetTicketMaxAge");
180    
181                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
182                            PasswordPolicy.class.getName(), actionRequest);
183    
184                    if (passwordPolicyId <= 0) {
185    
186                            // Add password policy
187    
188                            PasswordPolicyServiceUtil.addPasswordPolicy(
189                                    name, description, changeable, changeRequired, minAge,
190                                    checkSyntax, allowDictionaryWords, minAlphanumeric, minLength,
191                                    minLowerCase, minNumbers, minSymbols, minUpperCase, regex,
192                                    history, historyCount, expireable, maxAge, warningTime,
193                                    graceLimit, lockout, maxFailure, lockoutDuration,
194                                    resetFailureCount, resetTicketMaxAge, serviceContext);
195                    }
196                    else {
197    
198                            // Update password policy
199    
200                            PasswordPolicyServiceUtil.updatePasswordPolicy(
201                                    passwordPolicyId, name, description, changeable, changeRequired,
202                                    minAge, checkSyntax, allowDictionaryWords, minAlphanumeric,
203                                    minLength, minLowerCase, minNumbers, minSymbols, minUpperCase,
204                                    regex, history, historyCount, expireable, maxAge, warningTime,
205                                    graceLimit, lockout, maxFailure, lockoutDuration,
206                                    resetFailureCount, resetTicketMaxAge, serviceContext);
207                    }
208            }
209    
210    }