Mentawai Web Framework

Rev

Rev 355 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 soliveira 1
/*
2
 * Mentawai Web Framework http://mentawai.lohis.com.br/
3
 * Copyright (C) 2005  Sergio Oliveira Jr. (sergio.oliveira.jr@gmail.com)
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2.1 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 */
19
package org.mentawai.filter;
20
 
21
import java.util.ArrayList;
22
import java.util.Iterator;
23
import java.util.LinkedList;
24
import java.util.List;
25
 
26
import org.mentawai.action.BaseLoginAction;
27
import org.mentawai.ajax.AjaxAction;
28
import org.mentawai.authorization.Authorizable;
29
import org.mentawai.authorization.AuthorizationManager;
30
import org.mentawai.authorization.Group;
31
import org.mentawai.authorization.Permission;
32
import org.mentawai.core.Action;
33
import org.mentawai.core.Context;
34
import org.mentawai.core.Filter;
35
import org.mentawai.core.InvocationChain;
36
 
37
/**
38
 * A filter to handle user authorization.
39
 * You should use this filter to protect your actions from unauthorized access.
40
 *
41
 * @author Sergio Oliveira
42
 */
43
public class AuthorizationFilter implements Filter {
44
 
45
        public static final String ACCESSDENIED = "accessdenied";
46
 
47
        public static final String AJAX_DENIED = AuthenticationFilter.AJAX_DENIED;
48
 
49
    private List<String> groups = null;
50
    private List<String> permissions = null;
51
    private List<Group> listGroups;
355 robertwgil 52
    private boolean both = false;
2 soliveira 53
 
54
    public AuthorizationFilter() {
55
 
56
        // we want to use dynamic validation...
57
    }
77 soliveira 58
 
59
    public AuthorizationFilter(Enum<?> ... es) {
60
        this(toString(es));
61
    }
62
 
63
    private static String[] toString(Enum<?> ... es) {
64
        String[] s = new String[es.length];
65
        int index = 0;
66
        for(Enum<?> e : es) {
67
                s[index++] = e.toString();
68
        }
69
        return s;
70
    }
71
 
2 soliveira 72
        public AuthorizationFilter(String ... groups) {
73
 
74
                this.groups = new ArrayList<String>(groups.length);
75
 
76
                if (groups.length == 1) {
77
 
78
                        String[] s = groups[0].split("\\s*\\,\\s*");
79
 
80
                        if (s.length > 1) {
81
 
82
                                // we are talking about the old version... without varargs...
83
 
84
                                for(int i=0;i<s.length;i++) {
85
 
86
                                        this.groups.add(s[i]);
87
                                }
88
 
89
                                return;
90
                        }
91
                }
92
 
93
        for(int i=0;i<groups.length;i++) {
94
 
95
            this.groups.add(groups[i]);
96
 
97
        }
98
        }
99
 
100
    public AuthorizationFilter(List<Object> groups) {
101
        this.groups = new ArrayList<String>(groups.size());
102
        Iterator<Object> iter = groups.iterator();
103
        while(iter.hasNext()) {
104
            Object obj = iter.next();
105
            if (obj instanceof Group) {
106
                Group g = (Group) obj;
107
                this.groups.add(g.getName());
108
            } else if (obj instanceof String) {
109
                String s = (String) obj;
110
                this.groups.add(s);
111
 
112
            } else if (obj instanceof Permission) {
113
 
114
                if (this.permissions == null) {
115
 
116
                        this.permissions = new LinkedList<String>();
117
                }
118
 
119
                Permission p = (Permission) obj;
120
 
121
                this.permissions.add(p.getName());
122
            }
123
        }
124
    }
125
 
126
    public AuthorizationFilter(Permission ... permissions) {
127
 
128
        this.permissions = new ArrayList<String>(permissions.length);
129
 
130
        for(int i=0;i<permissions.length;i++) {
131
 
132
                this.permissions.add(permissions[i].getName());
133
 
134
        }
135
 
136
    }
137
 
138
    /**
139
     *
140
     * @param groups
141
     * @param permission
142
     * @deprecated
143
     */
144
    public AuthorizationFilter(String groups, Permission permission) {
145
        this(groups);
146
        this.permissions = new ArrayList<String>(1);
147
        this.permissions.add(permission.getName());
148
    }
149
 
150
    /**
151
     *
152
     * @param groups
153
     * @param permission
154
     */
155
    public AuthorizationFilter(List<Object> groups, Permission permission) {
156
        this(groups);
157
        this.permissions = new ArrayList<String>(1);
158
        this.permissions.add(permission.getName());
159
    }
160
 
161
    public AuthorizationFilter(List<Object> groups, Permission ... permissions) {
162
        this(groups);
163
        this.permissions = new ArrayList<String>(permissions.length);
164
 
165
        for(int i=0;i<permissions.length;i++) {
166
                this.permissions.add(permissions[i].getName());
167
        }
168
    }
169
 
170
        /**
171
         * The default implementation of this method returns true for everything.
172
         *
173
         * You can override this method to create the authorization logic for your entire application.
174
         *
175
         * @param action
176
         * @param actionName
177
         * @param innerAction
178
         * @param user The user in the session (can be null)
179
         * @param userGroups The user groups (can be null)
180
         * @return true if authorized, false otherwise
181
         */
182
        public boolean isAuthorized(Action action, String actionName, String innerAction, Object user, List userGroups) {
183
 
184
                return true;
185
 
186
        }
187
 
188
        @SuppressWarnings("unchecked")
189
        public String filter(InvocationChain chain) throws Exception {
190
 
358 robertwgil 191
                if(!BaseLoginAction.isLogged(chain.getAction().getSession())){
192
                        return ACCESSDENIED;
193
                }
194
 
2 soliveira 195
        Action action = chain.getAction();
196
 
197
        Object pojo = chain.getPojo();
198
 
199
        Object actionImpl = pojo != null ? pojo : action;
200
 
201
        Context session = action.getSession();
202
 
203
        List usergroups = BaseLoginAction.getUserGroups(session);
204
 
205
        Object user = BaseLoginAction.getUserSession(session);
206
 
355 robertwgil 207
        boolean hasGroup = false;
208
        boolean hasPermission = false;
2 soliveira 209
 
210
        if (this.groups == null && this.permissions == null) {
211
 
212
                if (actionImpl instanceof Authorizable) {
213
 
214
                        Authorizable authorizable = (Authorizable) actionImpl;
215
 
355 robertwgil 216
                        hasGroup = authorizable.authorize(chain.getInnerAction(), user, usergroups);
2 soliveira 217
 
218
                } else {
219
 
355 robertwgil 220
                        hasGroup = isAuthorized(action, chain.getActionName(), chain.getInnerAction(), user, usergroups);
2 soliveira 221
                }
222
 
223
        } else {
224
 
355 robertwgil 225
 
2 soliveira 226
                if (groups != null && groups.size() > 0) {
227
 
228
                    for(int i=0;i<groups.size();i++) {
229
                        for(int j=0;j<usergroups.size();j++) {
230
 
231
                                String group = groups.get(i).toString();
232
                                Object objGroup = usergroups.get(j);
233
                                String usergroup = null;
234
 
235
                                if (objGroup instanceof String) {
236
                                        usergroup = objGroup.toString();
237
 
238
                                } else if (objGroup instanceof Group) {
239
                                        usergroup = ((Group) objGroup).getName();
240
 
241
                                }
242
 
243
                                if (group.startsWith("!")) {
244
                                        if (usergroup.equalsIgnoreCase(group.substring(1))) {
355 robertwgil 245
                                            hasGroup = false;
2 soliveira 246
                                        }else{
355 robertwgil 247
                                                hasGroup = true;
2 soliveira 248
                                            i = groups.size();
249
                                        j = usergroups.size();
250
                                        }
251
 
252
                                }else {
253
                                        if (usergroup.equalsIgnoreCase(group)) {
355 robertwgil 254
                                                hasGroup = true;
2 soliveira 255
                                                 i = groups.size();
256
                                        j = usergroups.size();
257
                                        }
258
                                }
259
 
260
                        }
261
                    }
355 robertwgil 262
 
2 soliveira 263
                }
264
 
265
                if (permissions != null && permissions.size() > 0) {
266
 
267
                    Iterator iter = usergroups.iterator();
268
                    String usergroup = null;
269
 
270
                    while(iter.hasNext()) {
271
                        Object objGroup = iter.next();
272
 
273
                        if (objGroup instanceof List) {
274
                                listGroups = (List<Group>) objGroup;
275
 
276
                                for(int k=0;k<listGroups.size();k++) {
277
                                Group ggg = ((Group) objGroup);
278
                                for(int a=0;a<permissions.size();a++) {
279
                                        String ppp = permissions.get(a).substring(1);
280
                                        if (AuthorizationManager.check(ggg, ppp)) {
355 robertwgil 281
                                            hasPermission = true;
2 soliveira 282
                                                break;
283
                                        }
284
                                }
285
                        }
286
 
287
                        } else if (objGroup instanceof String) {
288
                                        usergroup = objGroup.toString();
289
 
290
                                        for(int a=0;a<permissions.size();a++) {
291
                                                String ppp = permissions.get(a);
292
                                                if (AuthorizationManager.check(usergroup, ppp)) {
355 robertwgil 293
                                                    hasPermission = true;
2 soliveira 294
                                                        break;
295
                                                }
296
                                        }
297
 
298
                            } else if (objGroup instanceof Group) {
299
                                Group ggg = ((Group) objGroup);
300
 
301
                                for(int a=0;a<permissions.size();a++) {
302
                                        String ppp = permissions.get(a);
303
                                        if (AuthorizationManager.check(ggg, ppp)) {
355 robertwgil 304
                                            hasPermission = true;
2 soliveira 305
                                                break;
306
                                        }
307
                                     }
308
                            }
309
 
310
                    }
311
 
312
                }
313
 
314
        }
315
 
355 robertwgil 316
        boolean ok = false;
317
 
318
        if (both) {
319
            ok = hasGroup && hasPermission;
320
 
321
        } else {
322
            ok = hasGroup || hasPermission;
323
 
324
        }
325
 
326
 
2 soliveira 327
        if (!ok) {
328
                if (actionImpl instanceof AjaxAction) {
329
                        return AJAX_DENIED;
330
                }
331
 
332
            return ACCESSDENIED;
333
        }
334
 
355 robertwgil 335
 
2 soliveira 336
                return chain.invoke();
337
        }
338
 
339
    public void destroy() { }
340
 
355 robertwgil 341
 
342
    public AuthorizationFilter both(){
343
        this.both = true;
344
        return this;
345
    }
346
 
2 soliveira 347
}