001 package org.apache.turbine.services.security.torque; 002 003 /* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022 import java.io.Serializable; 023 024 import java.sql.Connection; 025 026 import org.apache.torque.om.ObjectKey; 027 import org.apache.torque.om.Persistent; 028 029 import org.apache.turbine.om.security.SecurityEntity; 030 import org.apache.turbine.util.security.TurbineSecurityException; 031 032 /** 033 * All the Torque Security objects (User, Group, Role, Permission) are 034 * derived from this class which contains the base compare and management 035 * methods for all security objects. 036 * 037 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a> 038 * @version $Id: TorqueObject.java 1096130 2011-04-23 10:37:19Z ludwig $ 039 */ 040 041 public abstract class TorqueObject 042 implements SecurityEntity, 043 Comparable, 044 Persistent, 045 Serializable 046 { 047 048 static final long serialVersionUID = 5619862273774652856L; 049 050 /** The underlying database Object which is proxied */ 051 protected Persistent obj = null; 052 053 /** 054 * Constructs a new TorqueObject 055 * 056 */ 057 public TorqueObject() 058 { 059 } 060 061 /** 062 * Constructs a new Object with the specified name. 063 * 064 * @param name The name of the new object. 065 */ 066 public TorqueObject(String name) 067 { 068 this.setName(name); 069 } 070 071 /** 072 * This Constructor is used when a Manager 073 * has retrieved a list of Database Objects from the peer and 074 * must 'wrap' them into TorqueObjects. 075 * 076 * @param obj An Object from the peer 077 */ 078 public TorqueObject(Persistent obj) 079 { 080 this.obj = obj; 081 } 082 083 /** 084 * Returns the underlying Object for the Peer 085 * 086 * @return The underlying persistent object 087 * 088 */ 089 public abstract Persistent getPersistentObj(); 090 091 /** 092 * Returns the name of this object 093 * 094 * @return The name of the object 095 */ 096 public abstract String getName(); 097 098 /** 099 * Sets the name of this object 100 * 101 * @param name The name of the object 102 */ 103 public abstract void setName(String name); 104 105 /** 106 * getter for the object primaryKey. 107 * 108 * @return the object primaryKey as an Object 109 */ 110 public ObjectKey getPrimaryKey() 111 { 112 Persistent p = getPersistentObj(); 113 if (p != null) 114 { 115 return p.getPrimaryKey(); 116 } 117 else 118 { 119 return null; 120 } 121 } 122 123 /** 124 * Sets the PrimaryKey for the object. 125 * 126 * @param primaryKey The new PrimaryKey for the object. 127 * 128 * @exception Exception This method might throw an exceptions 129 */ 130 public void setPrimaryKey(ObjectKey primaryKey) 131 throws Exception 132 { 133 getPersistentObj().setPrimaryKey(primaryKey); 134 } 135 136 /** 137 * Sets the PrimaryKey for the object. 138 * 139 * @param primaryKey the String should be of the form produced by 140 * ObjectKey.toString(). 141 * 142 * @exception Exception This method might throw an exceptions 143 */ 144 public void setPrimaryKey(String primaryKey) 145 throws Exception 146 { 147 getPersistentObj().setPrimaryKey(primaryKey); 148 } 149 150 /** 151 * Returns whether the object has been modified, since it was 152 * last retrieved from storage. 153 * 154 * @return True if the object has been modified. 155 */ 156 public boolean isModified() 157 { 158 return getPersistentObj().isModified(); 159 } 160 161 /** 162 * Returns whether the object has ever been saved. This will 163 * be false, if the object was retrieved from storage or was created 164 * and then saved. 165 * 166 * @return true, if the object has never been persisted. 167 */ 168 public boolean isNew() 169 { 170 return getPersistentObj().isNew(); 171 } 172 173 /** 174 * Setter for the isNew attribute. This method will be called 175 * by Torque-generated children and Peers. 176 * 177 * @param b the state of the object. 178 */ 179 public void setNew(boolean b) 180 { 181 getPersistentObj().setNew(b); 182 } 183 184 /** 185 * Sets the modified state for the object. 186 * 187 * @param m The new modified state for the object. 188 */ 189 public void setModified(boolean m) 190 { 191 getPersistentObj().setModified(m); 192 } 193 194 /** 195 * Stores the object in the database. If the object is new, 196 * it inserts it; otherwise an update is performed. 197 * 198 * @param torqueName The name under which the object should be stored. 199 * 200 * @exception Exception This method might throw an exceptions 201 */ 202 public void save(String torqueName) 203 throws Exception 204 { 205 getPersistentObj().save(torqueName); 206 } 207 208 /** 209 * Stores the object in the database. If the object is new, 210 * it inserts it; otherwise an update is performed. This method 211 * is meant to be used as part of a transaction, otherwise use 212 * the save() method and the connection details will be handled 213 * internally 214 * 215 * @param con A Connection object to save the object 216 * 217 * @exception Exception This method might throw an exceptions 218 */ 219 public void save(Connection con) 220 throws Exception 221 { 222 getPersistentObj().save(con); 223 } 224 225 /** 226 * Makes changes made to the TorqueObject permanent. 227 * 228 * @throws TurbineSecurityException if there is a problem while 229 * saving data. 230 */ 231 public abstract void save() 232 throws TurbineSecurityException; 233 234 /** 235 * Used for ordering TorqueObjects. 236 * 237 * @param obj The Object to compare to. 238 * @return -1 if the name of the other object is lexically greater than this 239 * group, 1 if it is lexically lesser, 0 if they are equal. 240 */ 241 public int compareTo(Object obj) 242 { 243 if (this.getClass() != obj.getClass()) 244 { 245 throw new ClassCastException(); 246 } 247 String name1 = ((SecurityEntity) obj).getName(); 248 String name2 = this.getName(); 249 250 return name2.compareTo(name1); 251 } 252 253 /** 254 * Compares this with another <code>BaseObject</code> instance. If 255 * <code>obj</code> is an instance of <code>BaseObject</code>, delegates to 256 * <code>equals(BaseObject)</code>. Otherwise, returns <code>false</code>. 257 * 258 * @param obj The object to compare to. 259 * @return Whether equal to the object specified. 260 */ 261 public boolean equals(Object obj) 262 { 263 if (obj != null && obj instanceof TorqueObject) 264 { 265 return equals((TorqueObject) obj); 266 } 267 else 268 { 269 return false; 270 } 271 } 272 273 /** 274 * Compares the primary key of this instance with the key of another. 275 * 276 * @param torqueObject The TorqueObject to compare to. 277 * @return Whether the primary keys are equal. 278 */ 279 public boolean equals(TorqueObject torqueObject) 280 { 281 if (torqueObject == null) 282 { 283 return false; 284 } 285 if (this == torqueObject) 286 { 287 return true; 288 } 289 else if (getPrimaryKey() == null || torqueObject.getPrimaryKey() == null) 290 { 291 return false; 292 } 293 else 294 { 295 return getPrimaryKey().equals(torqueObject.getPrimaryKey()); 296 } 297 } 298 299 /** 300 * If the primary key is not <code>null</code>, return the hashcode of the 301 * primary key. Otherwise calls <code>Object.hashCode()</code>. 302 * 303 * @return an <code>int</code> value 304 */ 305 public int hashCode() 306 { 307 ObjectKey ok = getPrimaryKey(); 308 if (ok == null) 309 { 310 return super.hashCode(); 311 } 312 313 return ok.hashCode(); 314 } 315 }