Coverage Report

Coverage Report - pt.digitalis.dif.utils.extensions.cms.Node

Classes in this File

Line Coverage

Branch Coverage

Complexity

Node

0/113

0/60

2,219

 /**
  * 2010, Digitalis Informatica. All rights reserved. Distribuicao e Gestao de Informatica, Lda. Estrada de Paco de Arcos
  * num.9 - Piso -1 2780-666 Paco de Arcos Telefone: (351) 21 4408990 Fax: (351) 21 4408999 http://www.digitalis.pt
  */
 
 package pt.digitalis.dif.utils.extensions.cms;
 
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
 import pt.digitalis.dif.controller.security.objects.IDIFUser;
 import pt.digitalis.dif.exception.security.IdentityManagerException;
 import pt.digitalis.dif.ioc.DIFIoCRegistry;
 import pt.digitalis.dif.utils.extensions.cms.exception.AlreadyDeletedException;
 import pt.digitalis.dif.utils.extensions.cms.exception.ContentManagerException;
 import pt.digitalis.dif.utils.extensions.cms.exception.NodeNotFoundException;
 import pt.digitalis.dif.utils.extensions.cms.exception.NodeWithNodesException;
 
 /**
  * Content node definition class
  * 
  * @author Pedro Viegas <a href="mailto:pviegas@digitalis.pt">pviegas@digitalis.pt</a><br/>
  * @created 2010/10/06
  */
 public class Node {
 
     /** the node ACL */
     private List<ACLEntry> accessList;
 
     /** The contentManager */
     private IContentManager contentManager;
 
     /** The date when the document was created */
     private Date creationDate;
 
     /** the creator user ID */
     private String creatorID;
 
     /** The node description */
     private String description;
 
     /** the full path name with all parent nodes */
     private String fullPathName;
 
     /** the node unique identifier */
     private Long id;
 
     /** True if the node object has already been deleted in the repository */
     private boolean isDeleted = false;
 
     /**  */
     private boolean isPublic;
 
     /** the node name. Unique within the node */
     private String name;
 
     /** The parent node ID, if it is not a root node */
     private Long parentNodeId;
 
     /** The current user */
     private IDIFUser user;
 
     /**
      * Constructor
      * 
      * @param parentNodeId
      *            the parent node ID
      * @param name
      *            the node Name
      * @param creatorID
      *            the creator ID
      * @param user
      *            the user instantiating the Node
      */
     public Node(Long parentNodeId, String name, String creatorID, IDIFUser user)
     {
         this.creatorID = creatorID;
         this.name = name;
         this.parentNodeId = parentNodeId;
         this.user = user;
         this.creationDate = new Date();
     }
 
     /**
      * Node is deleted in DB. Object ID property is set to null
      * 
      * @return T if update was succeeded
      * @throws IdentityManagerException
      * @throws ContentManagerException
      */
     public boolean delete() throws IdentityManagerException, ContentManagerException
     {
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         boolean ret = getContentManager().deleteNode(id, user);
 
         // object ID is set to null
         if (ret)
         {
             isDeleted = true;
             id = null;
         }
 
         return ret;
     }
 
     /**
      * Node is deleted in DB, as well has its child nodes. Object ID property is set to null
      * 
      * @return T if update was succeeded
      * @throws IdentityManagerException
      * @throws ContentManagerException
      */
     public boolean deleteCascade() throws IdentityManagerException, ContentManagerException
     {
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         boolean ret = false;
 
         try
         {
             ret = getContentManager().deleteNode(id, user, true);
         }
         catch (NodeWithNodesException e)
         {
             // never should happen, since it is a cascade delete...
         }
 
         // object ID is set to null
         id = null;
 
         return ret;
     }
 
     /**
      * Get ACL.
      * 
      * @return the accessList value
      * @throws ContentManagerException
      */
     public List<ACLEntry> getACL() throws ContentManagerException
     {
         if (accessList == null)
         {
             accessList = getContentManager().getNodeACL(id);
         }
 
         return accessList;
     }
 
     /**
      * Lazy load for content manager
      * 
      * @return the content manager
      */
     private IContentManager getContentManager()
     {
         if (contentManager == null)
             contentManager = DIFIoCRegistry.getRegistry().getImplementation(IContentManager.class);
 
         return contentManager;
     }
 
     /**
      * Inspector for the 'creationDate' attribute.
      * 
      * @return the creationDate value
      */
     public Date getCreationDate()
     {
         return creationDate;
     }
 
     /**
      * Inspector for the 'creatorID' attribute.
      * 
      * @return the creatorID value
      */
     public String getCreatorID()
     {
         return creatorID;
     }
 
     /**
      * Inspector for the 'description' attribute.
      * 
      * @return the description value
      */
     public String getDescription()
     {
         return description;
     }
 
     /**
      * Inspector for the 'fullPathName' attribute.
      * 
      * @return the fullPathName value
      */
     public String getFullPathName()
     {
         return fullPathName;
     }
 
     /**
      * Inspector for the 'id' attribute.
      * 
      * @return the id value
      */
     public Long getId()
     {
         return id;
     }
 
     /**
      * @return the node inner nodes
      * @throws IdentityManagerException
      * @throws ContentManagerException
      */
     public List<Node> getInnerNodes() throws IdentityManagerException, ContentManagerException
     {
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         return getContentManager().getNodesByParentNode(id, user);
     }
 
     /**
      * @return the node content elements
      * @throws IdentityManagerException
      * @throws ContentManagerException
      */
     public List<ContentItem> getItems() throws IdentityManagerException, ContentManagerException
     {
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         return getContentManager().getContentByParentNode(id, user);
     }
 
     /**
      * Inspector for the 'name' attribute.
      * 
      * @return the name value
      */
     public String getName()
     {
         return name;
     }
 
     /**
      * @return the parent Node
      * @throws IdentityManagerException
      * @throws ContentManagerException
      */
     public Node getParentNode() throws IdentityManagerException, ContentManagerException
     {
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         return getContentManager().getNodeById(parentNodeId, user);
     }
 
     /**
      * Inspector for the 'parentNodeId' attribute.
      * 
      * @return the parentNodeId value
      */
     public Long getParentNodeId()
     {
         return parentNodeId;
     }
 
     /**
      * Inspector for the 'user' attribute.
      * 
      * @return the user value
      */
     public IDIFUser getUser()
     {
         return user;
     }
 
     /**
      * Grants Node access to group. Grant access is done immediately
      * 
      * @param groupId
      *            the group to grant access
      * @return T if grant was succeeded
      * @throws ContentManagerException
      */
     public boolean grantAccessGroup(String groupId) throws ContentManagerException
     {
         ACLEntry entry = null;
 
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         boolean ret = getContentManager().grantNodeAccessToGroup(id, groupId);
 
         if (ret && accessList != null)
         {
             entry = new ACLEntry();
             entry.setGroupID(groupId);
             accessList.add(entry);
         }
 
         return ret;
     }
 
     /**
      * Grants Node access to user. Grant access is done immediately
      * 
      * @param user
      *            the user to grant access
      * @return T if grant was succeeded
      * @throws ContentManagerException
      */
     public boolean grantAccessUser(IDIFUser user) throws ContentManagerException
     {
         ACLEntry entry = null;
 
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         boolean ret = getContentManager().grantNodeAccessToUser(id, user);
 
         if (ret && accessList != null)
         {
             entry = new ACLEntry();
             entry.setUserID(user.getID());
             accessList.add(entry);
         }
 
         return ret;
     }
 
     /**
      * Inspector for the 'isDeleted' attribute.
      * 
      * @return the isDeleted value
      */
     public boolean isDeleted()
     {
         return isDeleted;
     }
 
     /**
      * Inspector for the 'isPublic' attribute.
      * 
      * @return the isPublic value
      */
     public boolean isPublic()
     {
         return isPublic;
     }
 
     /**
      * Revokes Node access to group. revoke access is done immediately
      * 
      * @param groupId
      *            the group to revoke access
      * @return T if revoke was succeeded
      * @throws ContentManagerException
      */
     public boolean revokeAccessGroup(String groupId) throws ContentManagerException
     {
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         boolean ret = getContentManager().revokeNodeAccessToGroup(id, groupId);
 
         if (ret && accessList != null)
         {
             List<ACLEntry> newList = new ArrayList<ACLEntry>();
             for (ACLEntry entry: accessList)
             {
                 if (entry.isUserEntry() || !entry.getGroupID().equals(groupId))
                     newList.add(entry);
             }
             accessList = newList;
         }
 
         return ret;
     }
 
     /**
      * Revokes Node access to group. revoke access is done immediately
      * 
      * @param user
      *            the user to revoke access
      * @return T if revoke was succeeded
      * @throws ContentManagerException
      */
     public boolean revokeAccessUser(IDIFUser user) throws ContentManagerException
     {
         if (isDeleted)
             throw new AlreadyDeletedException();
 
         boolean ret = getContentManager().revokeNodeAccessToUser(id, user);
 
         if (ret && accessList != null)
         {
             List<ACLEntry> newList = new ArrayList<ACLEntry>();
             for (ACLEntry entry: accessList)
             {
                 if (entry.isGroupEntry() || !entry.getUserID().equals(user.getID()))
                     newList.add(entry);
             }
             accessList = newList;
         }
 
         return ret;
     }
 
     /**
      * Modifier for the 'creationDate' attribute.
      * 
      * @param creationDate
      *            the new creationDate value to set
      */
     public void setCreationDate(Date creationDate)
     {
         this.creationDate = creationDate;
     }
 
     /**
      * Modifier for the 'creatorID' attribute.
      * 
      * @param creatorID
      *            the new creatorID value to set
      */
     public void setCreatorID(String creatorID)
     {
         this.creatorID = creatorID;
     }
 
     /**
      * Modifier for the 'description' attribute.
      * 
      * @param description
      *            the new description value to set
      */
     public void setDescription(String description)
     {
         this.description = description;
     }
 
     /**
      * Modifier for the 'fullPathName' attribute.
      * 
      * @param fullPathName
      *            the new fullPathName value to set
      */
     public void setFullPathName(String fullPathName)
     {
         this.fullPathName = fullPathName;
     }
 
     /**
      * Modifier for the 'id' attribute.
      * 
      * @param id
      *            the new id value to set
      */
     public void setId(Long id)
     {
         this.id = id;
     }
 
     /**
      * Modifier for the 'name' attribute.
      * 
      * @param name
      *            the new name value to set
      */
     public void setName(String name)
     {
         this.name = name;
     }
 
     /**
      * Modifier for the 'parentNodeId' attribute.
      * 
      * @param parentNodeId
      *            the new parentNodeId value to set
      */
     public void setParentNodeId(long parentNodeId)
     {
         this.parentNodeId = parentNodeId;
     }
 
     /**
      * Modifier for the 'isPublic' attribute.
      * 
      * @param isPublic
      *            the new isPublic value to set
      */
     public void setPublic(boolean isPublic)
     {
         this.isPublic = isPublic;
     }
 
     /**
      * Sets the 'user' attribute.
      * 
      * @param user
      *            the user currently using the object
      */
     public void setUser(IDIFUser user)
     {
         this.user = user;
     }
 
     /**
      * Updates the Node with current object values. If the Node doesn't exist than it is inserted
      * 
      * @return T if update was succeeded
      * @throws IdentityManagerException
      * @throws ContentManagerException
      */
     public boolean update() throws IdentityManagerException, ContentManagerException
     {
         Node node = null;
         if (isDeleted || id == null)
         {
             node = getContentManager().addNode(this);
             id = node.getId();
         }
         else
         {
             try
             {
                 node = getContentManager().updateNode(this);
             }
             catch (NodeNotFoundException e)
             {
                 node = getContentManager().addNode(this);
                 id = node.getId();
             }
         }
         return true;
     }
 
 }

1	0	/**
2		* 2010, Digitalis Informatica. All rights reserved. Distribuicao e Gestao de Informatica, Lda. Estrada de Paco de Arcos
3		* num.9 - Piso -1 2780-666 Paco de Arcos Telefone: (351) 21 4408990 Fax: (351) 21 4408999 http://www.digitalis.pt
4		*/
5
6		package pt.digitalis.dif.utils.extensions.cms;
7
8		import java.util.ArrayList;
9		import java.util.Date;
10		import java.util.List;
11
12		import pt.digitalis.dif.controller.security.objects.IDIFUser;
13		import pt.digitalis.dif.exception.security.IdentityManagerException;
14		import pt.digitalis.dif.ioc.DIFIoCRegistry;
15		import pt.digitalis.dif.utils.extensions.cms.exception.AlreadyDeletedException;
16		import pt.digitalis.dif.utils.extensions.cms.exception.ContentManagerException;
17		import pt.digitalis.dif.utils.extensions.cms.exception.NodeNotFoundException;
18		import pt.digitalis.dif.utils.extensions.cms.exception.NodeWithNodesException;
19
20		/**
21		* Content node definition class
22		*
23		* @author Pedro Viegas <a href="mailto:pviegas@digitalis.pt">pviegas@digitalis.pt</a><br/>
24		* @created 2010/10/06
25		*/
26		public class Node {
27
28		/** the node ACL */
29		private List<ACLEntry> accessList;
30
31		/** The contentManager */
32		private IContentManager contentManager;
33
34		/** The date when the document was created */
35		private Date creationDate;
36
37		/** the creator user ID */
38		private String creatorID;
39
40		/** The node description */
41		private String description;
42
43		/** the full path name with all parent nodes */
44		private String fullPathName;
45
46		/** the node unique identifier */
47		private Long id;
48
49		/** True if the node object has already been deleted in the repository */
50	0	private boolean isDeleted = false;
51
52		/** */
53		private boolean isPublic;
54
55		/** the node name. Unique within the node */
56		private String name;
57
58		/** The parent node ID, if it is not a root node */
59		private Long parentNodeId;
60
61		/** The current user */
62		private IDIFUser user;
63
64		/**
65		* Constructor
66		*
67		* @param parentNodeId
68		* the parent node ID
69		* @param name
70		* the node Name
71		* @param creatorID
72		* the creator ID
73		* @param user
74		* the user instantiating the Node
75		*/
76	0	public Node(Long parentNodeId, String name, String creatorID, IDIFUser user)
77		{
78	0	this.creatorID = creatorID;
79	0	this.name = name;
80	0	this.parentNodeId = parentNodeId;
81	0	this.user = user;
82	0	this.creationDate = new Date();
83	0	}
84
85		/**
86		* Node is deleted in DB. Object ID property is set to null
87		*
88		* @return T if update was succeeded
89		* @throws IdentityManagerException
90		* @throws ContentManagerException
91		*/
92		public boolean delete() throws IdentityManagerException, ContentManagerException
93		{
94	0	if (isDeleted)
95	0	throw new AlreadyDeletedException();
96
97	0	boolean ret = getContentManager().deleteNode(id, user);
98
99		// object ID is set to null
100	0	if (ret)
101		{
102	0	isDeleted = true;
103	0	id = null;
104		}
105
106	0	return ret;
107		}
108
109		/**
110		* Node is deleted in DB, as well has its child nodes. Object ID property is set to null
111		*
112		* @return T if update was succeeded
113		* @throws IdentityManagerException
114		* @throws ContentManagerException
115		*/
116		public boolean deleteCascade() throws IdentityManagerException, ContentManagerException
117		{
118	0	if (isDeleted)
119	0	throw new AlreadyDeletedException();
120
121	0	boolean ret = false;
122
123		try
124		{
125	0	ret = getContentManager().deleteNode(id, user, true);
126		}
127	0	catch (NodeWithNodesException e)
128		{
129		// never should happen, since it is a cascade delete...
130		}
131
132		// object ID is set to null
133	0	id = null;
134
135	0	return ret;
136		}
137
138		/**
139		* Get ACL.
140		*
141		* @return the accessList value
142		* @throws ContentManagerException
143		*/
144		public List<ACLEntry> getACL() throws ContentManagerException
145		{
146	0	if (accessList == null)
147		{
148	0	accessList = getContentManager().getNodeACL(id);
149		}
150
151	0	return accessList;
152		}
153
154		/**
155		* Lazy load for content manager
156		*
157		* @return the content manager
158		*/
159		private IContentManager getContentManager()
160		{
161	0	if (contentManager == null)
162	0	contentManager = DIFIoCRegistry.getRegistry().getImplementation(IContentManager.class);
163
164	0	return contentManager;
165		}
166
167		/**
168		* Inspector for the 'creationDate' attribute.
169		*
170		* @return the creationDate value
171		*/
172		public Date getCreationDate()
173		{
174	0	return creationDate;
175		}
176
177		/**
178		* Inspector for the 'creatorID' attribute.
179		*
180		* @return the creatorID value
181		*/
182		public String getCreatorID()
183		{
184	0	return creatorID;
185		}
186
187		/**
188		* Inspector for the 'description' attribute.
189		*
190		* @return the description value
191		*/
192		public String getDescription()
193		{
194	0	return description;
195		}
196
197		/**
198		* Inspector for the 'fullPathName' attribute.
199		*
200		* @return the fullPathName value
201		*/
202		public String getFullPathName()
203		{
204	0	return fullPathName;
205		}
206
207		/**
208		* Inspector for the 'id' attribute.
209		*
210		* @return the id value
211		*/
212		public Long getId()
213		{
214	0	return id;
215		}
216
217		/**
218		* @return the node inner nodes
219		* @throws IdentityManagerException
220		* @throws ContentManagerException
221		*/
222		public List<Node> getInnerNodes() throws IdentityManagerException, ContentManagerException
223		{
224	0	if (isDeleted)
225	0	throw new AlreadyDeletedException();
226
227	0	return getContentManager().getNodesByParentNode(id, user);
228		}
229
230		/**
231		* @return the node content elements
232		* @throws IdentityManagerException
233		* @throws ContentManagerException
234		*/
235		public List<ContentItem> getItems() throws IdentityManagerException, ContentManagerException
236		{
237	0	if (isDeleted)
238	0	throw new AlreadyDeletedException();
239
240	0	return getContentManager().getContentByParentNode(id, user);
241		}
242
243		/**
244		* Inspector for the 'name' attribute.
245		*
246		* @return the name value
247		*/
248		public String getName()
249		{
250	0	return name;
251		}
252
253		/**
254		* @return the parent Node
255		* @throws IdentityManagerException
256		* @throws ContentManagerException
257		*/
258		public Node getParentNode() throws IdentityManagerException, ContentManagerException
259		{
260	0	if (isDeleted)
261	0	throw new AlreadyDeletedException();
262
263	0	return getContentManager().getNodeById(parentNodeId, user);
264		}
265
266		/**
267		* Inspector for the 'parentNodeId' attribute.
268		*
269		* @return the parentNodeId value
270		*/
271		public Long getParentNodeId()
272		{
273	0	return parentNodeId;
274		}
275
276		/**
277		* Inspector for the 'user' attribute.
278		*
279		* @return the user value
280		*/
281		public IDIFUser getUser()
282		{
283	0	return user;
284		}
285
286		/**
287		* Grants Node access to group. Grant access is done immediately
288		*
289		* @param groupId
290		* the group to grant access
291		* @return T if grant was succeeded
292		* @throws ContentManagerException
293		*/
294		public boolean grantAccessGroup(String groupId) throws ContentManagerException
295		{
296	0	ACLEntry entry = null;
297
298	0	if (isDeleted)
299	0	throw new AlreadyDeletedException();
300
301	0	boolean ret = getContentManager().grantNodeAccessToGroup(id, groupId);
302
303	0	if (ret && accessList != null)
304		{
305	0	entry = new ACLEntry();
306	0	entry.setGroupID(groupId);
307	0	accessList.add(entry);
308		}
309
310	0	return ret;
311		}
312
313		/**
314		* Grants Node access to user. Grant access is done immediately
315		*
316		* @param user
317		* the user to grant access
318		* @return T if grant was succeeded
319		* @throws ContentManagerException
320		*/
321		public boolean grantAccessUser(IDIFUser user) throws ContentManagerException
322		{
323	0	ACLEntry entry = null;
324
325	0	if (isDeleted)
326	0	throw new AlreadyDeletedException();
327
328	0	boolean ret = getContentManager().grantNodeAccessToUser(id, user);
329
330	0	if (ret && accessList != null)
331		{
332	0	entry = new ACLEntry();
333	0	entry.setUserID(user.getID());
334	0	accessList.add(entry);
335		}
336
337	0	return ret;
338		}
339
340		/**
341		* Inspector for the 'isDeleted' attribute.
342		*
343		* @return the isDeleted value
344		*/
345		public boolean isDeleted()
346		{
347	0	return isDeleted;
348		}
349
350		/**
351		* Inspector for the 'isPublic' attribute.
352		*
353		* @return the isPublic value
354		*/
355		public boolean isPublic()
356		{
357	0	return isPublic;
358		}
359
360		/**
361		* Revokes Node access to group. revoke access is done immediately
362		*
363		* @param groupId
364		* the group to revoke access
365		* @return T if revoke was succeeded
366		* @throws ContentManagerException
367		*/
368		public boolean revokeAccessGroup(String groupId) throws ContentManagerException
369		{
370	0	if (isDeleted)
371	0	throw new AlreadyDeletedException();
372
373	0	boolean ret = getContentManager().revokeNodeAccessToGroup(id, groupId);
374
375	0	if (ret && accessList != null)
376		{
377	0	List<ACLEntry> newList = new ArrayList<ACLEntry>();
378	0	for (ACLEntry entry: accessList)
379		{
380	0	if (entry.isUserEntry() \|\| !entry.getGroupID().equals(groupId))
381	0	newList.add(entry);
382		}
383	0	accessList = newList;
384		}
385
386	0	return ret;
387		}
388
389		/**
390		* Revokes Node access to group. revoke access is done immediately
391		*
392		* @param user
393		* the user to revoke access
394		* @return T if revoke was succeeded
395		* @throws ContentManagerException
396		*/
397		public boolean revokeAccessUser(IDIFUser user) throws ContentManagerException
398		{
399	0	if (isDeleted)
400	0	throw new AlreadyDeletedException();
401
402	0	boolean ret = getContentManager().revokeNodeAccessToUser(id, user);
403
404	0	if (ret && accessList != null)
405		{
406	0	List<ACLEntry> newList = new ArrayList<ACLEntry>();
407	0	for (ACLEntry entry: accessList)
408		{
409	0	if (entry.isGroupEntry() \|\| !entry.getUserID().equals(user.getID()))
410	0	newList.add(entry);
411		}
412	0	accessList = newList;
413		}
414
415	0	return ret;
416		}
417
418		/**
419		* Modifier for the 'creationDate' attribute.
420		*
421		* @param creationDate
422		* the new creationDate value to set
423		*/
424		public void setCreationDate(Date creationDate)
425		{
426	0	this.creationDate = creationDate;
427	0	}
428
429		/**
430		* Modifier for the 'creatorID' attribute.
431		*
432		* @param creatorID
433		* the new creatorID value to set
434		*/
435		public void setCreatorID(String creatorID)
436		{
437	0	this.creatorID = creatorID;
438	0	}
439
440		/**
441		* Modifier for the 'description' attribute.
442		*
443		* @param description
444		* the new description value to set
445		*/
446		public void setDescription(String description)
447		{
448	0	this.description = description;
449	0	}
450
451		/**
452		* Modifier for the 'fullPathName' attribute.
453		*
454		* @param fullPathName
455		* the new fullPathName value to set
456		*/
457		public void setFullPathName(String fullPathName)
458		{
459	0	this.fullPathName = fullPathName;
460	0	}
461
462		/**
463		* Modifier for the 'id' attribute.
464		*
465		* @param id
466		* the new id value to set
467		*/
468		public void setId(Long id)
469		{
470	0	this.id = id;
471	0	}
472
473		/**
474		* Modifier for the 'name' attribute.
475		*
476		* @param name
477		* the new name value to set
478		*/
479		public void setName(String name)
480		{
481	0	this.name = name;
482	0	}
483
484		/**
485		* Modifier for the 'parentNodeId' attribute.
486		*
487		* @param parentNodeId
488		* the new parentNodeId value to set
489		*/
490		public void setParentNodeId(long parentNodeId)
491		{
492	0	this.parentNodeId = parentNodeId;
493	0	}
494
495		/**
496		* Modifier for the 'isPublic' attribute.
497		*
498		* @param isPublic
499		* the new isPublic value to set
500		*/
501		public void setPublic(boolean isPublic)
502		{
503	0	this.isPublic = isPublic;
504	0	}
505
506		/**
507		* Sets the 'user' attribute.
508		*
509		* @param user
510		* the user currently using the object
511		*/
512		public void setUser(IDIFUser user)
513		{
514	0	this.user = user;
515	0	}
516
517		/**
518		* Updates the Node with current object values. If the Node doesn't exist than it is inserted
519		*
520		* @return T if update was succeeded
521		* @throws IdentityManagerException
522		* @throws ContentManagerException
523		*/
524		public boolean update() throws IdentityManagerException, ContentManagerException
525		{
526	0	Node node = null;
527	0	if (isDeleted \|\| id == null)
528		{
529	0	node = getContentManager().addNode(this);
530	0	id = node.getId();
531		}
532		else
533		{
534		try
535		{
536	0	node = getContentManager().updateNode(this);
537		}
538	0	catch (NodeNotFoundException e)
539		{
540	0	node = getContentManager().addNode(this);
541	0	id = node.getId();
542		}
543		}
544	0	return true;
545		}
546
547		}