ini

README.md

+<pre>
+                        .__                          
+  ____             _____|  |__ _____ _______   ____  
+_/ __ \   ______  /  ___/  |  \\__  \\_  __ \_/ __ \ 
+\  ___/  /_____/  \___ \|   Y  \/ __ \|  | \/\  ___/ 
+ \___  >         /____  >___|  (____  /__|    \___  >
+     \/               \/     \/     \/            \/ 
+
+</pre>
+
+## e-share
+
+... is the erica version of share
\ No newline at end of file

_id

+_design/e-share

lists/up.js

+function(head, req) {
+
+    var share       = require("lib/vaclab/share"),
+    global          = require("lib/vaclab/global"),
+    id              = req.query.id,
+    doc             = [],
+    con     = [], // calibrationObjectNames
+    coo     = [], // calibrationObjectDocs
+    aon     = [], // AuxObjectNames
+    aoo     = [], // AuxObjectDocs
+    stn     = [], // StandardNames
+    sto     = [], // StandardDocs
+    ikresn  = [], // int. calib. with Results- Names
+    ikreso  = [], // int.calib. with Results- obnjects
+    scoo    = [],
+    cuco    = {},
+    defCuCo = [{Name:"CUCO"}],
+    constDoc,
+    result,
+    row,
+    iksign ="",iik=-1,
+    rv,sstdn,istd,sstdo,caon,jao,ccoo,
+    globals         = global.globals;
+
+    start(share.startJson);
+
+    if(id){
+        while(row = getRow()) {
+            rv = row.value;
+
+            if(rv.Calibration &&
+               rv._id == id){
+                doc = rv;
+            }
+
+            if(rv.Calibration &&
+               rv.Calibration.Type =="IK" &&
+               rv.Calibration.Result &&
+               rv.Calibration.Result.Values){
+                iksign = rv.Calibration.Sign.split(/[-_]+/)[0];
+                iik = share.indexOf(ikresn,iksign);
+
+                if(iik == -1){
+                    ikresn.push(iksign);
+                    ikreso.push(rv.Calibration.Result.Values);
+                }else{
+                    ikreso[iik] = rv.Calibration.Result.Values;
+                }
+            }
+
+            if(rv.Constants){
+                constDoc = rv.Constants;
+            }
+
+            if(rv.Standard &&
+               rv.Standard.Type &&
+               share.indexOf(stn,rv.Standard.Type) == -1){
+                stn.push(rv.Standard.Type);
+                sto.push(rv.Standard);
+            }
+
+            if(rv.CalibrationObject &&
+               rv.CalibrationObject.Name &&
+               share.indexOf(con,rv.CalibrationObject.Name) == -1){
+                con.push(rv.CalibrationObject.Name);
+                coo.push(rv.CalibrationObject);
+
+            }
+
+            if(rv.AuxObject &&
+               rv.AuxObject.Name &&
+               share.indexOf(con,rv.AuxObject.Name) == -1){
+                aon.push(rv.AuxObject.Name);
+                aoo.push(rv.AuxObject);
+
+            }
+        } // while
+
+        if(doc){
+	    
+            var standardArr   = doc.Calibration.Standard.split("|"),
+            twoStandards      = standardArr.length == 2 ? true : false,
+            standardStr1      = standardArr[0],
+            standardPos1      = share.indexOf(stn,standardStr1);
+	    
+            
+            standardObj1 = sto[standardPos1];
+	    
+            if(standardObj1.AuxObject){
+                for(iao in standardObj1.AuxObject){
+                    caon = standardObj1.AuxObject[iao];
+                    jao =  share.indexOf(aon,caon);
+                    if(jao > -1){
+                        standardObj1.AuxObject[iao] = aoo[jao];
+                    }
+                }
+            }
+	    
+            doc.Calibration.Measurement.Standard = standardObj1;
+	    
+            if(twoStandards){
+		standardStr2 = standardArr[1];
+                standardPos2 = share.indexOf(stn,standardStr2);
+		
+		standardObj2 = sto[standardPos2];
+		
+		if(standardObj1.AuxObject){
+                    for(iao in standardObj2.AuxObject){
+			caon = standardObj2.AuxObject[iao];
+			jao =  share.indexOf(aon,caon);
+			if(jao > -1){
+                            standardObj2.AuxObject[iao] = aoo[jao];
+			}
+                    }
+		}
+		
+		doc.Calibration.Measurement.Standard = [standardObj1, standardObj2];
+		
+	    }
+	    
+            for(ico in coo){
+                ccoo = coo[ico];
+                // gibt es Values für das co?:
+                iik = share.indexOf(ikresn,ccoo.Sign);
+		
+                if(iik >-1){
+                    ccoo.Values = ikreso[iik];
+                }
+                if(ccoo.Device &&
+                   ccoo.Device.Standard &&
+                   ccoo.Device.Standard == standardStr1 ||
+                   (twoStandards  && ccoo.Device.Standard == standardStr2) ){
+		    
+                    if(ccoo.AuxObject){
+                        for(iao in ccoo.AuxObject){
+                            caon = ccoo.AuxObject[iao];
+                            jao =  share.indexOf(aon,caon);
+                            if(jao > -1){
+                                ccoo.AuxObject[iao] = aoo[jao];
+                            }
+                        }
+			
+                    }
+                    scoo.push(ccoo);
+                }
+            }
+
+            if(!doc.Calibration.Measurement){
+                doc.Calibration.Measurement = {};
+            }
+
+            if(!doc.Calibration.Measurement.CalibrationObject){
+                doc.Calibration.Measurement.CalibrationObject =
+                    defCuCo.concat(scoo);
+            }else{
+                cuco = doc.Calibration.Measurement.CalibrationObject[0];
+                doc.Calibration.Measurement.CalibrationObject = [cuco].concat(scoo);
+            }
+            doc.Calibration.Constants            = constDoc;
+	    
+            result = doc;
+	}else{
+            result = {error:"no doc with id: " + id};
+	}
+    }else{
+	result = {error:"no id provided"};
+    }
+    
+    send(toJSON(result));
+    
+}

views/calib/map.js

+function(doc) {
+
+
+// tasks können wahrscheinlich raus ???
+
+    var git  = require("views/lib/check-return_task");
+    var cru  = require("views/lib/check-return_doc-parts");
+
+    /**
+     * Da im MP-doc recipes und Tasks von allgemeiner
+     * Bedeutung stehen, muss dies für das  Zusammenbauen der
+     * recipes auch emitted werden
+     */
+    if(doc.MP){
+        var _task_obj  = git.MP(doc);
+    } // Messprog.- dokument
+    
+    if(doc.Calibration){
+        var _res       = cru.calibration(doc);
+	
+    }// Calibration
+    
+    if(doc.Constants){
+        var _res       =  cru.const(doc);
+    } // Constants
+    
+    if(doc.Standard){
+        var _task_obj  = git.Standard(doc);
+        var _res       = cru.standard(doc);
+	
+    } // Standard
+    
+    if(doc.CalibrationObject){
+        var _task_obj  = git.CalObj(doc);
+        var _res       = cru.calObj(doc);
+	
+    }// CalibrationObject
+    
+    if(doc.AuxObject){
+        var _task_obj  = git.AuxObj(doc);
+        var _res       = cru.auxObj(doc);
+    } // AuxObjects
+    
+    if(_task_obj){
+        git.RetTask(_task_obj);
+    }
+    
+    if(_res && _res._avail){
+        emit(_res.key, _res.value);
+    }
+}
\ No newline at end of file

views/lib/check-return_doc-parts.js

+exports.calibration = function(doc){
+    var dc = doc.Calibration,
+    _res = {  "_avail"  : false,
+              "key"     : "",
+              "value"   : ""
+           };
+
+    if(doc._id =='000_TEMPLATE'){
+
+        _res._avail  = true;
+        _res.key     = 'Calibration_Template';
+        _res.value   = doc;
+
+    }else{
+        if(dc.Year     &&
+           dc.Sign     &&
+           dc.Standard &&
+           dc.Type){
+            /**
+             * Es werden nur noch Dokumente
+             * benutzt, die Sign(s) mit der Syntax
+             * xxxx-yyyy oder  xxxx_yyyy besitzen
+             * und die nicht vom Typ NN sind
+             */
+            var _csl = dc.Sign.split(/[-_]+/).length;
+
+            if((_csl == 2) &&
+                !(dc.Type == 'NN') ){
+
+                _res._avail = true;
+                _res.key    = dc.Year+'_'+dc.Type+'_'+ dc.Sign  ;
+
+                if(dc.Type == 'IK' &&
+                   dc.Result       &&
+                   dc.Result.Values){
+
+                    _res.key = dc.Year+'_'+dc.Type +'_'+ dc.Sign;
+
+                }
+                _res.value   = doc;
+            }
+        }
+    }
+    return(_res );
+};
+
+exports.allCalObj = function(doc){
+    var _res = {  "_avail"  : false,
+                  "key"     : "",
+                  "value"   : ""
+               },
+    co       = doc.CalibrationObject;
+
+    if(co.Name){
+	_res._avail = true;
+	_res.key    = co.Name;
+	_res.value  = doc;	
+    }
+
+    if(co.Device && co.Device.Name){
+	_res._avail = true;
+	_res.key    = co.Device.Name;
+	_res.value  = doc;	
+    }
+
+    return _res;
+};
+
+exports.calObj = function(doc){
+
+    var _res = {  "_avail"  : false,
+                  "key"     : "",
+                  "value"   : ""
+               },
+    co       = doc.CalibrationObject,
+    cod      = co.Device;
+
+
+    if(co.Type){
+        var _coType = co.Type;
+    }
+    if(co.Sign){
+        var _coSign = co.Sign;
+    }
+    if(cod.Standard){
+        var _coStd = cod.Standard;
+    }
+    if(co.Standard){
+        var _coStd = cod.Standard;
+    }
+    var _coDate = '';
+    if(co.Date){
+        _coDate = co.Date.Value.split(' ')[0];
+    }else{
+        // muss weh tun!
+        _coDate = '1999-01-01';
+    }
+
+    if(_coStd   &&
+       _coDate  &&
+       _coType  &&
+       _coSign   ){
+
+           _res._avail = true;
+           _res.key =  _coStd +'_'+ _coDate +'_'+_coType+'_'+ _coSign;
+           _res.value = doc;
+       }
+    return _res;
+};
+
+
+
+
+exports.auxObj = function(doc){
+
+    var _res = {  "_avail"  : false,
+                  "key"     : "",
+                  "value"   : ""
+               },
+    ao = doc.AuxObject;
+
+    if(ao.Name){
+        _res._avail = true;
+        _res.key    = ao.Name;
+        _res.value  = doc;
+
+    }
+    return _res;
+};
+
+/**
+ * Constants (die universiumsweit gültigen)
+ */
+exports.const = function(doc){
+    return {_avail:true,
+            key   :doc.Constants.Date.Value.slice(0,10),
+            value : doc
+           };
+};
+/**
+ * Standarddokumente
+ * diese müssen einen Namen oder
+ * einen Typ besitzen. Der param in der up list
+ * entscheidet anhand Name und Type welches
+ * Standarddokument benutzt wird
+ *
+ */
+exports.standard = function(doc){
+    var ds = doc.Standard,
+    _res = {  "_avail"  : false,
+              "key"     : "",
+              "value"   : ""
+           };
+
+    if((ds.Type  || ds.Name) &&
+        ds.Date   &&
+       (ds.Date.Value || ds.Date[0].Value)){
+
+        var _d1 = ds.Date.Value || ds.Date[0].Value;
+        var _d2 = _d1.split("-");
+
+        var date = [_d2[0],_d2[1],_d2[2]].join("-");
+
+        _res._avail = true;
+        _res.key = ds.Type + '_' + date;
+        _res.value = doc;
+
+        return(_res );
+
+    };
+};
+
+
+exports.allCustomers = function(doc){
+    var _res = {  "_avail"  : false,
+                  "key"     : "",
+                  "value"   : ""
+               },
+    o       = doc.Customer;
+    
+    if(o.Name){
+	_res._avail = true;
+	_res.key    = o.Name;
+	_res.value  = doc;	
+    }
+    return _res;
+};
+
+exports.allToDo = function(doc){
+    var _res = {  "_avail"  : false,
+                  "key"     : "",
+                  "value"   : ""
+               },
+    o       = doc.ToDo;
+    
+    if(o.Name || o.Sign){
+	_res._avail = true;
+	_res.key    = o.Name || o.Sign;
+	_res.value  = doc;	
+    }
+    return _res;
+};
+
+exports.servers = function(doc){
+    /*
+     * aus historischen Gründen hat(te) hier der key noch die Werte
+     * sollte in diwan geändert werden
+     */    
+    var _res = {  "_avail"  : true,
+                  "key"     : "Servers",
+                  "value"   : doc.Servers
+               };
+    
+    return _res;
+};
+
+exports.translations = function(doc){
+    /*
+     * aus historischen Gründen hat(te) hier der key noch die Werte
+     * sollte in diwan geändert werden
+     */    
+    var _res = {  "_avail"  : true,
+                  "key"     : "Translations",
+                  "value"   : doc.Translations
+               };
+    
+    return _res;
+};

views/lib/check-return_task.js

+exports.CalObj = function(doc){
+    var Obj = doc.CalibrationObject;
+    if(Obj.Tasks){
+	var noOfTasks = Obj.Tasks.length;
+	
+	return( {  "Tasks"    : Obj.Tasks,
+		   "name"     : (Obj.Name || Obj.Device.Name).replace(/\s/g, "_"),
+		   "_avail"   : noOfTasks > 0,
+		   "noOfTasks": noOfTasks,
+		   "Defaults" : Obj.Defaults || undefined
+		});
+    }else{
+	return({"_avail"     : false});
+	
+    }
+};
+
+exports.AuxObj = function(doc){
+  var Obj = doc.AuxObject;
+  if(Obj.Tasks){
+    var noOfTasks = Obj.Tasks.length;
+
+    return( { "Tasks"     : Obj.Tasks,
+              "name"     : Obj.Name.replace(/\s/g, "_"),
+              "_avail"   : noOfTasks > 0,
+              "noOfTasks": noOfTasks,
+              "Defaults" : Obj.Defaults || null
+            });
+  }else{
+    return({"_avail"     : false});
+
+  }
+};
+
+exports.MP = function(doc){
+    var Obj = doc.MP;
+    if(Obj.Tasks){
+	var noOfTasks = Obj.Tasks.length;
+	return( {  "Tasks"    : Obj.Tasks,
+		   "name"     : "MP",
+		   "_avail"   : noOfTasks > 0,
+		   "noOfTasks": noOfTasks,
+		   "Defaults" : Obj.Defaults || null
+		});
+    }else{
+	return({"_avail"     : false});
+    }
+};
+
+exports.Standard = function(doc){
+    var Obj = doc.Standard;
+    if(Obj.Tasks){
+	var noOfTasks = Obj.Tasks.length;
+	
+	return( { "Tasks"     : Obj.Tasks,
+		  "name"      : (Obj.Name || Obj.Type).replace(/\s/g, "_"),
+		  "_avail"    : noOfTasks > 0,
+		  "noOfTasks" : noOfTasks,
+		  "Defaults"  : Obj.Defaults || undefined
+		});
+    }else{
+	return({"_avail"      : false});
+	
+    }
+};
+
+exports.RetTask = function(retObj){
+    
+    if(retObj || retObj._avail){
+	
+	for (var i = 0; i < retObj.noOfTasks; i++) {
+	    
+	    var  _task = JSON.parse(JSON.stringify( retObj.Tasks[i]));
+	    
+	    var retKey =  retObj.name +"_"+_task.TaskName;
+	    
+	    _task.Defaults = retObj.Defaults || undefined;
+	    _task.TaskName = retKey;
+	    
+	    var retVal = {"Task"    :_task,
+			  "Defaults":retObj.Defaults
+			 };
+	    if(retVal && retKey){
+		
+		emit( retKey, retVal);
+		
+	    }
+	}
+    }
+};

views/lib/check.js

+exports.CalObjNames = function(Obj){
+    var    tmpco   = "",
+    i = 0,
+    cmco,
+    retCalObjNames = [];
+
+    if(Obj.Measurement &&
+       Obj.Measurement.CalibrationObject){
+        cmco = Obj.Measurement.CalibrationObject;
+        
+	for(i; i < cmco.length; i++ ){
+            retCalObjNames.push(
+		(cmco[i].Name || cmco[i].Device.Name)
+		    .replace(/\s/g, "_")
+	    );
+        }
+        emit(null,{CalObjNames:retCalObjNames});
+    }
+};
+
+exports.CalObjTask = function(Obj){
+    if(Obj.Tasks){
+        var noOfTasks = Obj.Tasks.length;
+
+        return( {  "Tasks"    : Obj.Tasks,
+                   "name"     : (Obj.Name || Obj.Device.Name).replace(/\s/g, "_"),
+                   "_avail"   : noOfTasks > 0,
+                   "noOfTasks": noOfTasks,
+                   "Defaults" : Obj.Defaults || undefined
+                });
+    }else{
+        return({"_avail"     : false});
+
+    }
+};
+
+exports.AuxObjTask = function(Obj){
+    if(Obj.Tasks){
+        var noOfTasks = Obj.Tasks.length;
+
+        return( { "Tasks"     : Obj.Tasks,
+                  "name"     : Obj.Name.replace(/\s/g, "_"),
+                  "_avail"   : noOfTasks > 0,
+                  "noOfTasks": noOfTasks,
+                  "Defaults" : Obj.Defaults || null
+                });
+    }else{
+        return({"_avail"     : false});
+
+    }
+};
+
+exports.MPTask = function(Obj){
+
+    if(Obj.Tasks){
+        var noOfTasks = Obj.Tasks.length;
+        return( {  "Tasks"    : Obj.Tasks,
+                   "name"     : "MP",
+                   "_avail"   : noOfTasks > 0,
+                   "noOfTasks": noOfTasks,
+                   "Defaults" : Obj.Defaults || null
+                });
+    }else{
+        return({"_avail"     : false});
+    }
+};
+exports.YampTask = function(Obj){
+
+    if(Obj.Tasks){
+	var noOfTasks = Obj.Tasks.length;
+        return( {  "Tasks"    : Obj.Tasks,
+                   "name"     : "",
+                   "_avail"   : noOfTasks > 0,
+                   "noOfTasks": noOfTasks,
+                   "Defaults" : Obj.Defaults || null
+                });
+    }else{
+        return({"_avail"     : false});
+    }
+};
+
+exports.StandardTask = function(Obj){
+    if(Obj.Tasks){
+        var noOfTasks = Obj.Tasks.length;
+
+        return( { "Tasks"     : Obj.Tasks,
+                  "name"      : (Obj.Name || Obj.Type).replace(/\s/g, "_"),
+                  "_avail"    : noOfTasks > 0,
+                  "noOfTasks" : noOfTasks,
+                  "Defaults"  : Obj.Defaults || undefined
+                });
+    }else{
+        return({"_avail"      : false});
+
+    }
+};
+
+exports.retTask = function(retObj){
+
+    if(retObj || retObj._avail){
+
+        for (var i = 0; i < retObj.noOfTasks; i++) {
+
+            var  _task = JSON.parse(JSON.stringify( retObj.Tasks[i]));
+
+
+	    if(retObj.name === ""){
+		var retKey =  _task.TaskName;
+	    }else{
+		var retKey =  retObj.name +"_"+_task.TaskName;
+	    }
+	    
+            _task.Defaults = retObj.Defaults || undefined;
+            _task.TaskName = retKey;
+
+            var retVal = {"Task"    :_task,
+                          "Defaults":retObj.Defaults
+                         };
+            if(retVal && retKey){
+
+                emit( retKey, retVal);
+
+            }
+        }
+    }
+};