001    /*
002      Copyright (C) 2002-2003 Laurent Martelli <laurent@aopsys.com>
003                              Renaud Pawlak <renaud@aopsys.com>
004    
005      This program is free software; you can redistribute it and/or modify
006      it under the terms of the GNU Lesser General Public License as
007      published by the Free Software Foundation; either version 2 of the
008      License, or (at your option) any later version.
009    
010      This program is distributed in the hope that it will be useful,
011      but WITHOUT ANY WARRANTY; without even the implied warranty of
012      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
013      GNU Lesser General Public License for more details.
014    
015      You should have received a copy of the GNU Lesser General Public License
016      along with this program; if not, write to the Free Software
017      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
018    
019    package org.objectweb.jac.aspects.user;
020    
021    import org.aopalliance.intercept.ConstructorInvocation;
022    import org.aopalliance.intercept.MethodInvocation;
023    import org.objectweb.jac.aspects.authentication.AuthenticationAC;
024    import org.objectweb.jac.aspects.gui.GuiAC;
025    import org.objectweb.jac.core.AspectComponent;
026    import org.objectweb.jac.core.Interaction;
027    import org.objectweb.jac.core.ObjectRepository;
028    import org.objectweb.jac.core.Wrapper;
029    import org.objectweb.jac.core.rtti.ClassItem;
030    import org.objectweb.jac.core.rtti.ClassRepository;
031    import org.objectweb.jac.core.rtti.FieldItem;
032    import org.objectweb.jac.util.Log;
033    import java.util.Collection;
034    import java.util.Iterator;
035    import java.util.Vector;
036    
037    /**
038     * This wrapper is used by the user aspect to implement several
039     * croscutting treatments.
040     */
041    
042    public class UserWrapper extends Wrapper {
043    
044            public UserWrapper(AspectComponent ac) {
045                    super(ac);
046            }
047    
048            /** Classes to initialize */
049            Vector classes = new Vector();
050            public void addClass(ClassItem cl) {
051                    classes.add(cl);
052            }
053    
054            /** 
055             * Set user attributes of an object.
056             *
057             * @param wrappee the object to initialize
058             * @param user the user object
059             */
060            protected void setUser(Object wrappee, Object user) {
061                    UserAC ac = (UserAC) getAspectComponent();
062                    ClassItem classItem = ClassRepository.get().getClass(wrappee);
063                    FieldItem[] fields = classItem.getFields();
064                    for (int i = 0; i < fields.length; i++) {
065                            if (fields[i].getTypeItem() == ac.getUserClass()) {
066                                    if (fields[i].getThroughAccessor(wrappee) == null) {
067                                            Log.trace(
068                                                    "user",
069                                                    "initializing field "
070                                                            + fields[i].getName()
071                                                            + " with "
072                                                            + GuiAC.toString(user));
073                                            try {
074                                                    fields[i].setThroughWriter(wrappee, user);
075                                            } catch (Exception e) {
076                                                    Log.error(
077                                                            "Failed to set user field "
078                                                                    + wrappee
079                                                                    + "."
080                                                                    + fields[i]
081                                                                    + " with "
082                                                                    + user);
083                                                    e.printStackTrace();
084                                            }
085                                    }
086                            }
087                    }
088            }
089    
090            protected Object getUser() {
091                    UserAC ac = (UserAC) getAspectComponent();
092                    Object user = attr(UserAC.USER);
093                    if (user == null) {
094                            // Get a user from authentication
095                            String authuser = (String) attr(AuthenticationAC.USER);
096                            if (authuser != null) {
097                                    Collection users =
098                                            ObjectRepository.getObjects(ac.getUserClass());
099                                    Iterator i = users.iterator();
100                                    // Find a user whose loginField matches the authenticated username
101                                    while (i.hasNext()) {
102                                            Object testedUser = i.next();
103                                            Object id =
104                                                    ac.getLoginField().getThroughAccessor(testedUser);
105                                            if (authuser.equals(id)) {
106                                                    user = testedUser;
107                                                    break;
108                                            }
109                                    }
110                            }
111                    }
112                    return user;
113            }
114    
115            /**
116             * Set the user attribute of new objects
117             */
118            public Object setUserOnNew(Interaction interaction) {
119                    Log.trace("user", "setUser for " + interaction.method);
120                    Object result = proceed(interaction);
121                    UserAC ac = (UserAC) getAspectComponent();
122                    Object user = getUser();
123    
124                    Log.trace("user", "user = " + user + "(" + GuiAC.toString(user) + ")");
125                    if (user != null) {
126                            setUser(interaction.wrappee, user);
127                    }
128                    return result;
129            }
130    
131            /**
132             * <p>Set user attributes of parameters.</p>
133             */
134            public Object setUser(Interaction interaction) {
135                    Log.trace("user", "setUser for " + interaction.method);
136                    Object result = proceed(interaction);
137                    UserAC ac = (UserAC) getAspectComponent();
138                    Object user = getUser();
139    
140                    Log.trace("user", "user = " + user + "(" + GuiAC.toString(user) + ")");
141                    if (user != null) {
142                            for (int i = 0; i < interaction.args.length; i++) {
143                                    if (classes
144                                            .contains(
145                                                    ClassRepository.get().getClass(interaction.args[i]))) {
146                                            Log.trace(
147                                                    "user",
148                                                    "Init param "
149                                                            + i
150                                                            + "("
151                                                            + interaction.args[i]
152                                                            + ") of "
153                                                            + interaction.method);
154                                            setUser(interaction.args[i], user);
155                                    }
156                            }
157                    }
158                    return result;
159            }
160    
161            public Object invoke(MethodInvocation invocation) throws Throwable {
162                    return setUser((Interaction) invocation);
163            }
164            public Object construct(ConstructorInvocation invocation)
165                    throws Throwable {
166                            return setUserOnNew((Interaction)invocation);
167            }
168    
169    }