001: /* Copyright 2001 The JA-SIG Collaborative. All rights reserved.
002: * See license distributed with this file and
003: * available online at http://www.uportal.org/license.html
004: */
005:
006: package org.jasig.portal.channels.permissionsmanager;
007:
008: import java.util.ArrayList;
009:
010: import org.jasig.portal.IPermissible;
011: import org.jasig.portal.security.IAuthorizationPrincipal;
012: import org.jasig.portal.security.IPermission;
013: import org.jasig.portal.services.EntityNameFinderService;
014: import org.apache.commons.logging.Log;
015: import org.apache.commons.logging.LogFactory;
016: import org.w3c.dom.Document;
017: import org.w3c.dom.Element;
018: import org.w3c.dom.NodeList;
019:
020: /**
021: * The class responsible for generating the monolithic XML file for CPermissionsManager
022: *
023: * @author Alex Vigdor
024: * @version $Revision: 35675 $
025: */
026: public class PermissionsXML {
027: private static final Log log = LogFactory
028: .getLog(PermissionsXML.class);
029:
030: /** Creates new PermissionsXML */
031: protected PermissionsXML() {
032: }
033:
034: /**
035: * @param session
036: * @return a <code>Document</code>
037: */
038: public static Document getViewDoc(PermissionsSessionData session) {
039: return getViewDoc(session, false);
040: }
041:
042: public static Document getViewDoc(PermissionsSessionData session,
043: boolean forceRefresh) {
044: synchronized (session) {
045: if (session.XML == null || forceRefresh) {
046: Document rDoc = org.jasig.portal.utils.DocumentFactory
047: .getNewDocument();
048: session.XML = rDoc;
049: session.owners = new IPermissible[0];
050: try {
051: Element root = rDoc
052: .createElement("CPermissionsManager");
053: rDoc.appendChild(root);
054:
055: if (session.staticData.get("prmOwners") != null) {
056: // use specified set of owners
057: log
058: .debug("PermissionsXML.getViewDoc(): using specified owners");
059: session.owners = (IPermissible[]) session.staticData
060: .get("prmOwners");
061: } else {
062: // use owners found in DB
063: log
064: .debug("PermissionsXML.getViewDoc(): using DB owners");
065: session.owners = RDBMPermissibleRegistry
066: .getAllPermissible();
067: }
068:
069: for (int i = 0; i < session.owners.length; i++) {
070: if (log.isDebugEnabled())
071: log
072: .debug("PermissionsXML.getViewDoc(): Configuring element for owner "
073: + session.owners[i]
074: .getOwnerName());
075: Element owner = rDoc.createElement("owner");
076: owner.setAttribute("name", session.owners[i]
077: .getOwnerName());
078: owner.setAttribute("token", session.owners[i]
079: .getOwnerToken());
080: owner.setAttribute("ipermissible",
081: session.owners[i].getClass().getName());
082:
083: String[] activities = session.owners[i]
084: .getActivityTokens();
085: for (int j = 0; j < activities.length; j++) {
086: Element act = rDoc
087: .createElement("activity");
088: act.setAttribute("token", activities[j]);
089: act.setAttribute("name", session.owners[i]
090: .getActivityName(activities[j]));
091: owner.appendChild(act);
092: }
093:
094: String[] targets = session.owners[i]
095: .getTargetTokens();
096: for (int k = 0; k < targets.length; k++) {
097: addTargetToOwnerElement(session.owners[i],
098: owner, targets[k]);
099: }
100: root.appendChild(owner);
101: }
102:
103: } catch (Exception e) {
104: log.error("Error getting the view doc for session "
105: + session, e);
106: }
107: }
108: }
109: return session.XML;
110: }
111:
112: public static Element addTargetToOwnerElement(IPermissible owner,
113: Element ownerEl, String target) {
114: Element tgt = ownerEl.getOwnerDocument()
115: .createElement("target");
116: tgt.setAttribute("token", target);
117: tgt.setAttribute("name", owner.getTargetName(target));
118: ownerEl.appendChild(tgt);
119: return tgt;
120: }
121:
122: public static void setSelected(PermissionsSessionData session,
123: String ipermissible, String type, String token,
124: boolean selected) {
125: if (log.isDebugEnabled())
126: log.debug("PermissionsXML.setSelected(): processing "
127: + ipermissible + " / " + type + " / " + token
128: + " / " + selected);
129: Element owner = getOwner(session, ipermissible);
130: Element s = owner;
131: String otoken = owner.getAttribute("token");
132: if (!type.equals("owner")) {
133: NodeList nl = owner.getElementsByTagName(type);
134: boolean found = false;
135: for (int i = 0; i < nl.getLength(); i++) {
136: Element x = (Element) nl.item(i);
137: if (x.getAttribute("token").equals(token)) {
138: s = x;
139: found = true;
140: break;
141: }
142: }
143: if (!found) {
144: if (type.equals("target")) {
145: for (int i = 0; i < session.owners.length; i++) {
146: if (session.owners[i].getOwnerToken().equals(
147: otoken)) {
148: s = addTargetToOwnerElement(
149: session.owners[i], owner, token);
150: break;
151: }
152: }
153: }
154: }
155: }
156: String value = "false";
157: if (selected) {
158: value = "true";
159: }
160: s.setAttribute("selected", value);
161: }
162:
163: public static void populatePrincipals(PermissionsSessionData session) {
164: if (session.principals != null) {
165: Document rDoc;
166: if (session.XML == null) {
167: rDoc = getViewDoc(session);
168: } else {
169: rDoc = session.XML;
170: }
171: Element root = rDoc.getDocumentElement();
172: IPermissible[] owners;
173: if (session.staticData.get("prmOwners") != null) {
174: // use specified set of owners
175: owners = (IPermissible[]) session.staticData
176: .get("prmOwners");
177: } else {
178: // use owners found in DB
179: owners = RDBMPermissibleRegistry.getAllPermissible();
180: }
181:
182: ArrayList ownerKeys = new ArrayList();
183: for (int x = 0; x < owners.length; x++) {
184: ownerKeys.add(owners[x].getOwnerToken());
185: }
186: //log.debug("PermissionsManager:: getting principals");
187: IAuthorizationPrincipal[] aps = session.principals;
188: for (int m = 0; m < aps.length; m++) {
189: try {
190: //log.debug("PermissionsManager:: iterating over principals");
191: Element ppl = rDoc.createElement("principal");
192: ppl.setAttribute("token", aps[m]
193: .getPrincipalString());
194: ppl
195: .setAttribute("type", aps[m].getType()
196: .getName());
197: String name = aps[m].getKey();
198: try {
199: name = EntityNameFinderService.instance()
200: .getNameFinder(aps[m].getType())
201: .getName(name);
202: } catch (Exception e) {
203: log.error(e, e);
204: }
205: ppl.setAttribute("name", name);
206: IPermission[] pms = aps[m].getAllPermissions();
207: for (int n = 0; n < pms.length; n++) {
208: if (ownerKeys.contains(pms[n].getOwner())) {
209: Element perm = rDoc
210: .createElement("permission");
211: perm.setAttribute("owner", pms[n]
212: .getOwner());
213: perm.setAttribute("principal", pms[n]
214: .getPrincipal());
215: perm.setAttribute("activity", pms[n]
216: .getActivity());
217: perm.setAttribute("type", pms[n].getType());
218: perm.setAttribute("target", pms[n]
219: .getTarget());
220: if (pms[n].getEffective() != null) {
221: perm.setAttribute("effective", pms[n]
222: .getEffective().toString());
223: }
224: if (pms[n].getExpires() != null) {
225: perm.setAttribute("expires", pms[n]
226: .getExpires().toString());
227: }
228: ppl.appendChild(perm);
229: }
230: }
231: root.appendChild(ppl);
232: } catch (Exception e) {
233: log.error(e, e);
234: }
235: }
236: }
237: }
238:
239: /**
240: * put your documentation comment here
241: * @param session
242: * @param tagname
243: */
244: public static void autoSelectSingleChoice(
245: PermissionsSessionData session, String tagname) {
246: boolean allsingle = true;
247: Element docRoot = PermissionsXML.getViewDoc(session)
248: .getDocumentElement();
249: NodeList nl = docRoot.getElementsByTagName("owner");
250: for (int l = 0; l < nl.getLength(); l++) {
251: Element o = (Element) nl.item(l);
252: if (o.getAttribute("selected") != null
253: && o.getAttribute("selected").equals("true")) {
254: NodeList cl = o.getElementsByTagName(tagname);
255: if (cl.getLength() == 1) {
256: ((Element) cl.item(0)).setAttribute("selected",
257: "true");
258: } else {
259: allsingle = false;
260: }
261: }
262: }
263: if (allsingle) {
264: if (tagname.equals("activity")) {
265: session.gotActivities = true;
266: }
267: if (tagname.equals("target")) {
268: session.gotTargets = true;
269: }
270: }
271: }
272:
273: public static String[] getSelectedTargets(
274: PermissionsSessionData session, Element owner) {
275: if (log.isDebugEnabled())
276: log
277: .debug("PermissionsXML.getSelectedTargets(): processing for "
278: + owner.getAttribute("name"));
279: ArrayList targets = new ArrayList();
280: Element o = owner;
281: if (o != null) {
282: NodeList tl = o.getElementsByTagName("target");
283: for (int i = 0; i < tl.getLength(); i++) {
284: Element target = (Element) tl.item(i);
285: if ((target.getAttribute("selected") != null)
286: && (target.getAttribute("selected")
287: .equals("true"))) {
288: targets.add(target.getAttribute("token"));
289: if (log.isDebugEnabled())
290: log
291: .debug("PermissionsXML.getSelectedTargets(): adding "
292: + target.getAttribute("token"));
293: }
294: }
295: }
296: return (String[]) targets.toArray(new String[0]);
297: }
298:
299: public static String[] getSelectedActivities(
300: PermissionsSessionData session, Element owner) {
301: if (log.isDebugEnabled())
302: log
303: .debug("PermissionsXML.getSelectedActivities(): processing for "
304: + owner.getAttribute("name"));
305: ArrayList activities = new ArrayList();
306: Element o = owner;
307: if (o != null) {
308: NodeList al = o.getElementsByTagName("activity");
309: for (int i = 0; i < al.getLength(); i++) {
310: Element activity = (Element) al.item(i);
311: if ((activity.getAttribute("selected") != null)
312: && (activity.getAttribute("selected")
313: .equals("true"))) {
314: activities.add(activity.getAttribute("token"));
315: if (log.isDebugEnabled())
316: log
317: .debug("PermissionsXML.getSelectedActivities(): adding "
318: + activity
319: .getAttribute("token"));
320: }
321: }
322: }
323: return (String[]) activities.toArray(new String[0]);
324: }
325:
326: public static Element[] getSelectedOwners(
327: PermissionsSessionData session) {
328: ArrayList owners = new ArrayList();
329: Document doc = getViewDoc(session);
330: NodeList ol = doc.getElementsByTagName("owner");
331: for (int i = 0; i < ol.getLength(); i++) {
332: Element owner = (Element) ol.item(i);
333: if ((owner.getAttribute("selected") != null)
334: && (owner.getAttribute("selected").equals("true"))) {
335: owners.add(owner);
336: }
337: }
338: return (Element[]) owners.toArray(new Element[0]);
339: }
340:
341: public static Element getOwner(PermissionsSessionData session,
342: String ipermissible) {
343: if (log.isDebugEnabled())
344: log
345: .debug("PermissionsXML.getOwner(): looking for owner of class "
346: + ipermissible);
347: Document doc = getViewDoc(session);
348: Element ro = null;
349: NodeList ol = doc.getElementsByTagName("owner");
350: for (int i = 0; i < ol.getLength(); i++) {
351: Element o = (Element) ol.item(i);
352: if (o.getAttribute("ipermissible").equals(ipermissible)) {
353: if (log.isDebugEnabled())
354: log
355: .debug("PermissionsXML.getOwner(): found owner of class "
356: + ipermissible
357: + " and token "
358: + o.getAttribute("token"));
359: ro = o;
360: break;
361: }
362: }
363: return ro;
364: }
365: }
|