1 /*
  2  * Copyright © [2008-2009] Novell, Inc.  All Rights Reserved.
  3  * 
  4  * USE AND REDISTRIBUTION OF THIS WORK IS SUBJECT TO THE DEVELOPER LICENSE AGREEMENT
  5  * OR OTHER AGREEMENT THROUGH WHICH NOVELL, INC. MAKES THE WORK AVAILABLE.  THIS WORK 
  6  * MAY NOT BE ADAPTED WITHOUT NOVELL'S PRIOR WRITTEN CONSENT.
  7  * 
  8  * NOVELL PROVIDES THE WORK "AS IS," WITHOUT ANY EXPRESS OR IMPLIED WARRANTY, 
  9  * INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR 
 10  * A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  NOVELL, THE AUTHORS OF THE WORK, AND THE 
 11  * OWNERS OF COPYRIGHT IN THE WORK ARE NOT LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER 
 12  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, 
 13  * OR IN CONNECTION WITH THE WORK OR THE USE OR OTHER DEALINGS IN THE WORK.
 14  */
 15 
 16 /**
 17  * @fileoverview
 18  * This file includes utility routines to convert JavaScript objects to Java dataobjects,
 19  * which is what Sentinel uses internally to represent the data it manipulates.
 20  */
 21 
 22 /**
 23  * Constructs a Java dataobject.
 24  * @param {Object} ctor
 25  * @param {Object} factory
 26  * @param {Object} propertyMap
 27  * @constructor
 28  * @private
 29  */
 30 function JSDataObject(ctor, factory, propertyMap){
 31 
 32     if (!propertyMap) {
 33         throw "Property map must not be null";
 34     }
 35     else 
 36         if (propertyMap.constructor != Object) {
 37             throw "Property map must be an object";
 38         }
 39     
 40     var saveFunction = function(dobj){
 41         dobj.save();
 42     };
 43     
 44     function copyToDataObj(src, target){
 45         for (var e in propertyMap) {
 46             if (src[e] && String(src[e]) != "null") {
 47                 target.setAttribute(e, src[e]);
 48             }
 49         }
 50     }
 51     
 52     function copyToJSON(src, target){
 53         for (var e in propertyMap) {
 54             if (e) {
 55                 target[e] = String(src.getAttribute(e));
 56             }
 57         }
 58     }
 59     
 60     function makeCriteria(qattr){
 61         try {
 62             var omd = factory.getMetaData();
 63             var qc = new Packages.esecurity.base.criteria.QueryCriteria(omd);
 64             var crit;
 65             var value;
 66             
 67             for (var key in qattr) {
 68                 if (!(key in propertyMap)) {
 69                     throw key + " is not in the property map for " + ctor.name;
 70                 }
 71                 
 72                 value = qattr[key];
 73                 if (value) {
 74                     crit = new Packages.esecurity.base.criteria.EqualToCriterion(omd, key, value);
 75                 }
 76                 else {
 77                     crit = new Packages.esecurity.base.criteria.IsNullCriterion(omd, key);
 78                 }
 79                 
 80                 qc.addCriterion(crit);
 81             }
 82         } 
 83         catch (e) {
 84             throw String(e.toString());
 85         }
 86         return qc;
 87     }
 88     
 89     function verifyRequired(jsobj){
 90         for (var e in propertyMap) {
 91             if (propertyMap[e].required && !(e in jsobj)) {
 92                 throw "Property " + e + " is required";
 93             }
 94         }
 95     }
 96     
 97     function wrap(obj, dataObject){
 98         obj.save = function(){
 99             try {
100                 copyToDataObj(this, dataObject);
101                 
102                 if (this.preSave && typeof this.preSave == "function") {
103                     this.preSave(dataObject);
104                 }
105                 
106                 verifyRequired(this);
107                 saveFunction(dataObject);
108                 
109                 if (this.postSave && typeof this.postSave  == "function") {
110                     return this.postSave(dataObject);
111                 }
112             } 
113             catch (e) {
114                 throw String(e.toString());
115             }
116         };
117         
118         obj.unwrap = function() {
119             copyToDataObj(this, dataObject);
120             return dataObject;
121         };
122     }
123 				
124 				/**
125 				 * 
126 				 * @param {Object} qattr
127 				 * @private
128 				 */
129     ctor.find = function(qattr){
130         try {
131             if (!qattr || qattr.constructor != Object) {
132                 throw "Attributes for find must be a JSON object";
133             }
134             var qc = makeCriteria(qattr);
135             if (ctor.preFind && typeof ctor.preFind == "function") {
136                 qc = ctor.preFind(qc);
137             }
138             
139             var list = factory.select(qc);
140             var ret = [];
141             if (!list || list.size() <= 0) {
142                 return ret;
143             }
144             
145             for (var i = 0; i < list.size(); ++i) {
146                 var jsobj = ctor.fromDataObject(list.get(i));
147                 if (jsobj.postFind && typeof jsobj.postFind == "function") {
148                     jsobj.postFind(list.get(i));
149                 }
150                 
151                 ret[i] = jsobj;
152             }
153         } 
154         catch (e) {
155             throw String(e.toString());
156         }
157         return ret;
158     };
159     
160 				/**
161 				 * 
162 				 * @param {Object} dobj
163 				 * @private
164 				 */
165     ctor.fromDataObject = function(dobj){
166         var obj = new ctor();
167         copyToJSON(dobj, obj);
168         wrap(obj, dobj);
169         return obj;
170     };
171     
172 				/**
173 				 * 
174 				 * @param {Object} props
175 				 * @private
176 				 */
177     ctor.prototype.toDataObject = function(props){
178         try {
179             var dobj = factory.create();
180 
181             if (props) {
182                 for (var e in propertyMap) {
183                     if (props[e]) {
184                         this[e] = props[e];
185                     }
186                 }
187             }
188             
189             wrap(this, dobj);
190         } 
191         catch (err) {
192             throw String(err.toString());
193         }
194         return this;
195     };
196 }
197