http://a73434.berlin.ptb.de/mediawiki/index.php/Konstanten#Tabelle

table of constatns list

	neue Datei:   lib/mustache.js
	neue Datei:   lib/share.js
	neue Datei:   lists/table_of.js
	geändert:   lists/up.js
	neue Datei:   templates/table.html
	neue Datei:   views/constants/map.js
	neue Datei:   views/reduceStandard/map.js
	neue Datei:   views/reduceStandard/reduce.js
	neue Datei:   views/reduceType/map.js
	neue Datei:   views/reduceType/reduce.js
	neue Datei:   views/reduceYear/map.js
	neue Datei:   views/reduceYear/reduce.js
	neue Datei:   views/sign-sign/map.js
	neue Datei:   views/standard-sign/map.js
	neue Datei:   views/standard-year/map.js
	neue Datei:   views/standard_type-sign/map.js
	neue Datei:   views/standard_year-sign/map.js
	neue Datei:   views/standard_year-type/map.js
	neue Datei:   views/standard_year_type-sign/map.js
	neue Datei:   views/standard_year_type_sign-doc/map.js
	neue Datei:   views/standard_year_type_sign/map.js
	neue Datei:   views/translations/map.js
	neue Datei:   views/type-sign/map.js
	gelöscht:    views/views.js
	neue Datei:   views/year-sign/map.js

lib/mustache.js

+/*
+ * CommonJS-compatible mustache.js module
+ *
+ * See http://github.com/janl/mustache.js for more info.
+ */
+
+/*
+  mustache.js — Logic-less templates in JavaScript
+
+  See http://mustache.github.com/ for more info.
+*/
+
+var Mustache = function () {
+  var _toString = Object.prototype.toString;
+
+  Array.isArray = Array.isArray || function (obj) {
+    return _toString.call(obj) == "[object Array]";
+  }
+
+  var _trim = String.prototype.trim, trim;
+
+  if (_trim) {
+    trim = function (text) {
+      return text == null ? "" : _trim.call(text);
+    }
+  } else {
+    var trimLeft, trimRight;
+
+    // IE doesn't match non-breaking spaces with \s.
+    if ((/\S/).test("\xA0")) {
+      trimLeft = /^[\s\xA0]+/;
+      trimRight = /[\s\xA0]+$/;
+    } else {
+      trimLeft = /^\s+/;
+      trimRight = /\s+$/;
+    }
+
+    trim = function (text) {
+      return text == null ? "" :
+        text.toString().replace(trimLeft, "").replace(trimRight, "");
+    }
+  }
+
+  var escapeMap = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': '&quot;',
+    "'": '&#39;'
+  };
+
+  function escapeHTML(string) {
+    return String(string).replace(/&(?!#?\w+;)|[<>"']/g, function (s) {
+      return escapeMap[s] || s;
+    });
+  }
+
+  var regexCache = {};
+  var Renderer = function () {};
+
+  Renderer.prototype = {
+    otag: "{{",
+    ctag: "}}",
+    pragmas: {},
+    buffer: [],
+    pragmas_implemented: {
+      "IMPLICIT-ITERATOR": true
+    },
+    context: {},
+
+    render: function (template, context, partials, in_recursion) {
+      // reset buffer & set context
+      if (!in_recursion) {
+        this.context = context;
+        this.buffer = []; // TODO: make this non-lazy
+      }
+
+      // fail fast
+      if (!this.includes("", template)) {
+        if (in_recursion) {
+          return template;
+        } else {
+          this.send(template);
+          return;
+        }
+      }
+
+      // get the pragmas together
+      template = this.render_pragmas(template);
+
+      // render the template
+      var html = this.render_section(template, context, partials);
+
+      // render_section did not find any sections, we still need to render the tags
+      if (html === false) {
+        html = this.render_tags(template, context, partials, in_recursion);
+      }
+
+      if (in_recursion) {
+        return html;
+      } else {
+        this.sendLines(html);
+      }
+    },
+
+    /*
+      Sends parsed lines
+    */
+    send: function (line) {
+      if (line !== "") {
+        this.buffer.push(line);
+      }
+    },
+
+    sendLines: function (text) {
+      if (text) {
+        var lines = text.split("\n");
+        for (var i = 0; i < lines.length; i++) {
+          this.send(lines[i]);
+        }
+      }
+    },
+
+    /*
+      Looks for %PRAGMAS
+    */
+    render_pragmas: function (template) {
+      // no pragmas
+      if (!this.includes("%", template)) {
+        return template;
+      }
+
+      var that = this;
+      var regex = this.getCachedRegex("render_pragmas", function (otag, ctag) {
+        return new RegExp(otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" + ctag, "g");
+      });
+
+      return template.replace(regex, function (match, pragma, options) {
+        if (!that.pragmas_implemented[pragma]) {
+          throw({message:
+            "This implementation of mustache doesn't understand the '" +
+            pragma + "' pragma"});
+        }
+        that.pragmas[pragma] = {};
+        if (options) {
+          var opts = options.split("=");
+          that.pragmas[pragma][opts[0]] = opts[1];
+        }
+        return "";
+        // ignore unknown pragmas silently
+      });
+    },
+
+    /*
+      Tries to find a partial in the curent scope and render it
+    */
+    render_partial: function (name, context, partials) {
+      name = trim(name);
+      if (!partials || partials[name] === undefined) {
+        throw({message: "unknown_partial '" + name + "'"});
+      }
+      if (!context || typeof context[name] != "object") {
+        return this.render(partials[name], context, partials, true);
+      }
+      return this.render(partials[name], context[name], partials, true);
+    },
+
+    /*
+      Renders inverted (^) and normal (#) sections
+    */
+    render_section: function (template, context, partials) {
+      if (!this.includes("#", template) && !this.includes("^", template)) {
+        // did not render anything, there were no sections
+        return false;
+      }
+
+      var that = this;
+
+      var regex = this.getCachedRegex("render_section", function (otag, ctag) {
+        // This regex matches _the first_ section ({{#foo}}{{/foo}}), and captures the remainder
+        return new RegExp(
+          "^([\\s\\S]*?)" +         // all the crap at the beginning that is not {{*}} ($1)
+
+          otag +                    // {{
+          "(\\^|\\#)\\s*(.+?)\\s*" +//  #foo (# == $2, foo == $3), not greedy
+          ctag +                    // }}
+
+          "\n*([\\s\\S]*?)" +       // between the tag ($2). leading newlines are dropped
+
+          otag +                    // {{
+          "\\/\\s*\\3\\s*" +        //  /foo (backreference to the opening tag).
+          ctag +                    // }}
+
+          "\\s*([\\s\\S]*)$",       // everything else in the string ($4). leading whitespace is dropped.
+
+        "g");
+      });
+
+
+      // for each {{#foo}}{{/foo}} section do...
+      return template.replace(regex, function (match, before, type, name, content, after) {
+        // before contains only tags, no sections
+        var renderedBefore = before ? that.render_tags(before, context, partials, true) : "",
+
+        // after may contain both sections and tags, so use full rendering function
+            renderedAfter = after ? that.render(after, context, partials, true) : "",
+
+        // will be computed below
+            renderedContent,
+
+            value = that.find(name, context);
+
+        if (type === "^") { // inverted section
+          if (!value || Array.isArray(value) && value.length === 0) {
+            // false or empty list, render it
+            renderedContent = that.render(content, context, partials, true);
+          } else {
+            renderedContent = "";
+          }
+        } else if (type === "#") { // normal section
+          if (Array.isArray(value)) { // Enumerable, Let's loop!
+            renderedContent = that.map(value, function (row) {
+              return that.render(content, that.create_context(row), partials, true);
+            }).join("");
+          } else if (that.is_object(value)) { // Object, Use it as subcontext!
+            renderedContent = that.render(content, that.create_context(value),
+              partials, true);
+          } else if (typeof value == "function") {
+            // higher order section
+            renderedContent = value.call(context, content, function (text) {
+              return that.render(text, context, partials, true);
+            });
+          } else if (value) { // boolean section
+            renderedContent = that.render(content, context, partials, true);
+          } else {
+            renderedContent = "";
+          }
+        }
+
+        return renderedBefore + renderedContent + renderedAfter;
+      });
+    },
+
+    /*
+      Replace {{foo}} and friends with values from our view
+    */
+    render_tags: function (template, context, partials, in_recursion) {
+      // tit for tat
+      var that = this;
+
+      var new_regex = function () {
+        return that.getCachedRegex("render_tags", function (otag, ctag) {
+          return new RegExp(otag + "(=|!|>|&|\\{|%)?([^#\\^]+?)\\1?" + ctag + "+", "g");
+        });
+      };
+
+      var regex = new_regex();
+      var tag_replace_callback = function (match, operator, name) {
+        switch(operator) {
+        case "!": // ignore comments
+          return "";
+        case "=": // set new delimiters, rebuild the replace regexp
+          that.set_delimiters(name);
+          regex = new_regex();
+          return "";
+        case ">": // render partial
+          return that.render_partial(name, context, partials);
+        case "{": // the triple mustache is unescaped
+        case "&": // & operator is an alternative unescape method
+          return that.find(name, context);
+        default: // escape the value
+          return escapeHTML(that.find(name, context));
+        }
+      };
+      var lines = template.split("\n");
+      for(var i = 0; i < lines.length; i++) {
+        lines[i] = lines[i].replace(regex, tag_replace_callback, this);
+        if (!in_recursion) {
+          this.send(lines[i]);
+        }
+      }
+
+      if (in_recursion) {
+        return lines.join("\n");
+      }
+    },
+
+    set_delimiters: function (delimiters) {
+      var dels = delimiters.split(" ");
+      this.otag = this.escape_regex(dels[0]);
+      this.ctag = this.escape_regex(dels[1]);
+    },
+
+    escape_regex: function (text) {
+      // thank you Simon Willison
+      if (!arguments.callee.sRE) {
+        var specials = [
+          '/', '.', '*', '+', '?', '|',
+          '(', ')', '[', ']', '{', '}', '\\'
+        ];
+        arguments.callee.sRE = new RegExp(
+          '(\\' + specials.join('|\\') + ')', 'g'
+        );
+      }
+      return text.replace(arguments.callee.sRE, '\\$1');
+    },
+
+    /*
+      find `name` in current `context`. That is find me a value
+      from the view object
+    */
+    find: function (name, context) {
+      name = trim(name);
+
+      // Checks whether a value is thruthy or false or 0
+      function is_kinda_truthy(bool) {
+        return bool === false || bool === 0 || bool;
+      }
+
+      var value;
+
+      // check for dot notation eg. foo.bar
+      if (name.match(/([a-z_]+)\./ig)) {
+        var childValue = this.walk_context(name, context);
+        if (is_kinda_truthy(childValue)) {
+          value = childValue;
+        }
+      } else {
+        if (is_kinda_truthy(context[name])) {
+          value = context[name];
+        } else if (is_kinda_truthy(this.context[name])) {
+          value = this.context[name];
+        }
+      }
+
+      if (typeof value == "function") {
+        return value.apply(context);
+      }
+      if (value !== undefined) {
+        return value;
+      }
+      // silently ignore unkown variables
+      return "";
+    },
+
+    walk_context: function (name, context) {
+      var path = name.split('.');
+      // if the var doesn't exist in current context, check the top level context
+      var value_context = (context[path[0]] != undefined) ? context : this.context;
+      var value = value_context[path.shift()];
+      while (value != undefined && path.length > 0) {
+        value_context = value;
+        value = value[path.shift()];
+      }
+      // if the value is a function, call it, binding the correct context
+      if (typeof value == "function") {
+        return value.apply(value_context);
+      }
+      return value;
+    },
+
+    // Utility methods
+
+    /* includes tag */
+    includes: function (needle, haystack) {
+      return haystack.indexOf(this.otag + needle) != -1;
+    },
+
+    // by @langalex, support for arrays of strings
+    create_context: function (_context) {
+      if (this.is_object(_context)) {
+        return _context;
+      } else {
+        var iterator = ".";
+        if (this.pragmas["IMPLICIT-ITERATOR"]) {
+          iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
+        }
+        var ctx = {};
+        ctx[iterator] = _context;
+        return ctx;
+      }
+    },
+
+    is_object: function (a) {
+      return a && typeof a == "object";
+    },
+
+    /*
+      Why, why, why? Because IE. Cry, cry cry.
+    */
+    map: function (array, fn) {
+      if (typeof array.map == "function") {
+        return array.map(fn);
+      } else {
+        var r = [];
+        var l = array.length;
+        for(var i = 0; i < l; i++) {
+          r.push(fn(array[i]));
+        }
+        return r;
+      }
+    },
+
+    getCachedRegex: function (name, generator) {
+      var byOtag = regexCache[this.otag];
+      if (!byOtag) {
+        byOtag = regexCache[this.otag] = {};
+      }
+
+      var byCtag = byOtag[this.ctag];
+      if (!byCtag) {
+        byCtag = byOtag[this.ctag] = {};
+      }
+
+      var regex = byCtag[name];
+      if (!regex) {
+        regex = byCtag[name] = generator(this.otag, this.ctag);
+      }
+
+      return regex;
+    }
+  };
+
+  return({
+    name: "mustache.js",
+    version: "0.4.2",
+
+    /*
+      Turns a template and view into HTML
+    */
+    to_html: function (template, view, partials, send_fun) {
+      var renderer = new Renderer();
+      if (send_fun) {
+        renderer.send = send_fun;
+      }
+      renderer.render(template, view || {}, partials);
+      if (!send_fun) {
+        return renderer.buffer.join("\n");
+      }
+    }
+  });
+}();
+
+
+//if (typeof module !== 'undefined' && module.exports) {
+    exports.name = Mustache.name;
+    exports.version = Mustache.version;
+
+    exports.to_html = function() {
+      return Mustache.to_html.apply(this, arguments);
+    };
+//} 

lib/share.js

+/**
+ * deprecated!
+ * all uses of generateHtml should be replaced
+ * by mustache.to_html().
+ *
+ */
+exports.generateHtml = function(format,_resArr,_key){
+    _key = _key || "key";
+    /**
+     * wenn Zeit ist kann hier mal der retType zerlegt werden
+     * um die html- tags autom. zusammenzubauen
+     */
+    var fArr = format.split(/[-_]+/),
+    noOfTags = fArr.length;
+    
+    var st = "", 
+    et = "", // start tag end tag 
+    mds = "<" + fArr[noOfTags-1] + ">",
+    mde = "</" + fArr[noOfTags-1] + ">",
+    md = "";
+    
+    for(var j =1; j < (noOfTags-1); ++j){
+	st = st + "<" + fArr[j] + ">";
+	et = "</" + fArr[j] + ">" + et;
+    }
+
+    for (var i = 0; i < _resArr.length; ++i){
+   	md = md + "<" + fArr[noOfTags-1] + ">" + 
+	    _resArr[i][_key] + 
+	    "</" + fArr[noOfTags-1] + ">"; 
+    }
+
+    return st + md +  et;
+};
+
+exports.defaultReplacement= function(task,defaults,query){
+
+    defaults = defaults || task.Defaults;
+    query    = query    || {};
+
+    if(defaults){
+	for(var i in defaults){
+	  
+	    var subs = new RegExp(i,'g');
+	    for(var j in task){
+		/**
+		 * diese properties werden von der 
+		 * Ersetzung ausgeschlossen
+		 */
+		if( (j != "Defaults") && 
+		    (j != "ErrorResponse") &&
+		    (j != "TaskName") &&
+		    (j != "DocPath") 
+		  ){
+		      /**
+		       * geht noch eine Ebene in die Tiefe
+		       * v.a. wegen PostProcessing 
+		       */
+		      if( typeof(task[j]) == "object"){ 
+			 
+			  for (var k in  task[j]){
+
+			      if(query[i]){
+				  task[j][k] = task[j][k].replace(subs,query[i]);
+			      }else{
+				  if(typeof task[j][k] == "string" ){
+				     
+				      task[j][k] = task[j][k].replace(subs,defaults[i]);				    
+				  }
+			      }
+			  }
+		      }
+		      if( typeof(task[j]) == "string"){  
+			
+			  if(query[i]){
+			      task[j] = task[j].replace(subs,query[i]);
+			  }else{
+			      task[j] = task[j].replace(subs,defaults[i]);
+			  }
+		      }
+		  }//!defaults
+	    }// for j in tasks
+	}// for in in defaults
+    }// have defaults
+    return task;
+};
+
+exports.test = "fffuuuu";
+
+var pad0 = function(n){
+    return n < 10 ? "0" + n : n;    
+};
+exports.pad0 = pad0;
+
+var vlDateString = function(){
+    var dt = new Date(),
+    Y = dt.getFullYear(),
+    M = pad0(dt.getMonth()+1),
+    D = pad0(dt.getDate()),
+    h = pad0(dt.getHours()),
+    m = pad0(dt.getMinutes());
+    return Y + '-' + M + '-' + D + " " + h+":" + m;
+};
+exports.vlDateString = vlDateString;
+
+var vlTimeString = function(){
+    var dt = new Date();
+    
+    return "" + dt.getTime();
+};
+exports.vlTimeString = vlTimeString;
+
+
+exports.indexOf = function(arr,obj) {
+  for (var i = 0; i < arr.length; i++) {
+    if (arr[i] == obj)
+      return i;
+  }
+  return -1;
+};
+
+
+/**
+ * http://stackoverflow.com/questions/18082/validate-numbers-in-javascript-isnumeric
+ */
+exports.isNumber = function(n) {
+    return !isNaN(parseFloat(n)) && isFinite(n);
+};
+
+exports.isArray = function(obj) {
+    if (obj.constructor.toString().indexOf("Array") == -1){
+	return false;    
+    }else{
+	return true;    
+    }
+    
+};
+
+
+exports.startHtml = { 
+    headers: {
+	"Content-type": "text/html"
+    }
+};
+
+exports.startJson = {
+    "headers": {
+        "Content-Type": "application/json"
+    }
+};
+
+exports.startCss = {
+    "headers": {
+        "Content-Type": "text/css"
+     }
+};
+ 

lists/table_of.js

+function(head, req) {
+
+    var share = require("lib/share"),
+    mustache  = require("lib/mustache"),
+    template  = this.templates.table,
+    Data      = [];
+    start(share.startHtml);
+    while(r = getRow()) {
+	Data.push(r.value);
+    }
+    send(mustache.to_html(template,{All:Data}));
+}
+

lists/up.js

 function(head, req) {
 
-    var share       = require("lib/vaclab/share"),
-    global          = require("lib/vaclab/global"),
+    var share       = require("lib/share"),
+
     id              = req.query.id,
     doc             = [],
     con     = [], // calibrationObjectNames
@@ -19,9 +19,9 @@ function(head, req) {
     result,
     row,
     iksign ="",iik=-1,
-    rv,sstdn,istd,sstdo,caon,jao,ccoo,
-    globals         = global.globals;
-
+    rv,sstdn,istd,sstdo,caon,jao,ccoo;
+    
+    
     start(share.startJson);
 
     if(id){

templates/table.html

+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<style>
+  .container {
+  display: table;
+  }
+  .row  {
+  display: table-row;
+  }
+  .c1, .c3, .c2, .c4 {
+  display: table-cell;
+  padding-right: 25px;
+  }
+  .c1 p, .c3 p, .c2 p, .c4 p{
+  margin: 1px 1px;
+  }
+</style>
+</head>
+<body>
+<div class="container">
+  {{#All}}
+  <div class="row">
+    <div class="c1">
+      <p>{{Type}}</p>
+    </div>
+    <div class="c2">
+      <p>{{Value}}</p>
+    </div>
+    <div class="c3">
+      <p>{{Unit}}</p>
+    </div>
+    <div class="c4">
+      <p>{{Comment}}</p>
+    </div>
+  </div>
+  {{/All}}
+</div>
+</body>
+</html>
\ No newline at end of file

views/constants/map.js

+function(doc) {
+    if(doc.CalibrationObject){
+	
+        var dc  = doc.CalibrationObject;
+        var dcn = dc.Name;
+        var dcc = dc.Constants;
+        var dcu = dc.Uncertainty;
+        var dcv = dc.Values;
+
+        if(dcc){
+            for (var i = 0; i < dcc.length; ++i){
+
+                emit(dcn+"_constants", dcc[i]);
+            }
+        }
+
+        if(dcv){
+            for (var i = 0; i < dcv.length; ++i){
+
+                emit(dcn+"_values", dcv[i]);
+            }
+        }
+
+        if(dcu){
+            for (var i = 0; i < dcu.length; ++i){
+
+                emit(dcn+"_uncertainty", dcu[i]);
+            }
+        }
+    }
+
+    if(doc.Constants){
+
+        var dcn = "constants";
+        var dc  = doc.Constants;
+        var dcc = dc.Constants;
+        var dcu = dc.Uncertainty;
+        var dcv = dc.Values;
+
+        if(dcc){
+            for (var i = 0; i < dcc.length; ++i){
+
+                emit(dcn+"_constants", dcc[i]);
+            }
+        }
+
+        if(dcv){
+            for (var i = 0; i < dcv.length; ++i){
+
+                emit(dcn+"_values", dcv[i]);
+            }
+        }
+
+        if(dcu){
+            for (var i = 0; i < dcu.length; ++i){
+
+                emit(dcn+"_uncertainty", dcu[i]);
+            }
+        }
+    }
+
+    if(doc.Standard){
+        var ds  = doc.Standard;
+        var dsn = ds.Name;
+        var dsc = ds.Constants;
+        var dsu = ds.Uncertainty;
+        var dsv = ds.Values;
+
+        if(dsc){
+            for (var i = 0; i < dsc.length; ++i){
+
+                emit(dsn+"_constants", dsc[i]);
+            }
+        }
+
+        if(dsv){
+            for (var i = 0; i < dcv.length; ++i){
+
+                emit(dsn+"_values", dsv[i]);
+            }
+        }
+
+        if(dsu){
+            for (var i = 0; i < dsu.length; ++i){
+
+                emit(dsn+"_uncertainty", dsu[i]);
+            }
+        }
+    }
+}
\ No newline at end of file

views/reduceStandard/map.js

+function(doc) {
+    if(doc.Calibration && 
+       doc.Calibration.Standard){
+        emit(doc.Calibration.Standard, null);
+    }
+}
\ No newline at end of file

views/reduceStandard/reduce.js

+function(k, v, c){
+    return null;
+}
\ No newline at end of file

views/reduceType/map.js

+function(doc) {
+    if(doc.Calibration && 
+       doc.Calibration.Type){
+        emit(doc.Calibration.Type, null);
+    }
+}
\ No newline at end of file

views/reduceType/reduce.js

+function(k, v, c){
+    return null;
+}
\ No newline at end of file

views/reduceYear/map.js

+function(doc) {
+    if(doc.Calibration &&
+       doc.Calibration.Year){
+        emit(doc.Calibration.Year, null);
+    }
+}
\ No newline at end of file

views/reduceYear/reduce.js

+function(k, v, c){
+    return null;
+}
\ No newline at end of file

views/sign-sign/map.js

+function(doc) {
+    if(doc.Calibration && 
+       doc.Calibration.Sign){
+        emit(doc.Calibration.Sign, doc.Calibration.Sign);
+    }
+}
\ No newline at end of file

views/standard-sign/map.js

+function(doc) {
+    if(doc.Calibration &&
+       doc.Calibration.Standard &&
+       doc.Calibration.Sign){
+        emit(doc.Calibration.Standard, doc.Calibration.Sign);
+    }
+}
\ No newline at end of file

views/standard-year/map.js

+function(doc) {
+    if(doc.Calibration &&
+       doc.Calibration.Standard &&
+       doc.Calibration.Year){
+        emit(doc.Calibration.Standard, doc.Calibration.Year);
+    }
+}

views/standard_type-sign/map.js

+function(doc) {
+    if(doc.Calibration &&
+       doc.Calibration.Standard &&
+       doc.Calibration.Sign &&
+       doc.Calibration.Type){
+
+        emit(doc.Calibration.Standard + "_" + doc.Calibration.Type,
+             doc.Calibration.Sign);
+
+    }
+}
\ No newline at end of file

views/standard_year-sign/map.js

+function(doc) {
+    if(doc.Calibration &&
+       doc.Calibration.Standard &&
+       doc.Calibration.Sign &&
+       doc.Calibration.Year){
+	
+        emit(doc.Calibration.Standard + "_" +
+             doc.Calibration.Year,
+             doc.Calibration.Sign);
+	
+    }
+}
\ No newline at end of file

views/standard_year-type/map.js

+function(doc) {
+    if(doc.Calibration &&
+       doc.Calibration.Standard &&
+       doc.Calibration.Sign){
+
+        emit(doc.Calibration.Standard + "_" +
+             doc.Calibration.Year,
+             doc.Calibration.Type);
+
+    }
+}
\ No newline at end of file

views/standard_year_type-sign/map.js

+function(doc) {
+    if(doc.Calibration &&
+       doc.Calibration.Standard &&
+       doc.Calibration.Sign &&
+       doc.Calibration.Type){
+
+        emit(doc.Calibration.Standard + "_" +
+             doc.Calibration.Year     + "_" +
+             doc.Calibration.Type,
+             doc.Calibration.Sign);
+
+
+    }
+}
\ No newline at end of file

views/standard_year_type_sign-doc/map.js

+function(doc) {
+    if(doc.Calibration &&
+       doc.Calibration.Standard &&
+       doc.Calibration.Sign &&
+       doc.Calibration.Type){
+
+        emit(doc.Calibration.Standard + "_" +
+             doc.Calibration.Year     + "_" +
+             doc.Calibration.Type     + "_" +
+             doc.Calibration.Sign,
+             doc);
+
+    }
+}
\ No newline at end of file