wmglobalqueue 2.4.5.1__py3-none-any.whl

wmglobalqueue-2.4.5.1.data/data/data/couchapps/WorkQueue/filters/queueFilter.js

@@ -0,0 +1,11 @@
+function(doc, req) {
+    if (doc._deleted){
+       return false;
+    }
+    
+    if (doc.type && doc.type === "WMCore.WorkQueue.DataStructs.WorkQueueElement.WorkQueueElement"){
+        var ele = doc["WMCore.WorkQueue.DataStructs.WorkQueueElement.WorkQueueElement"];
+        return (ele['ChildQueueUrl'] === req.query.childUrl && ele['ParentQueueUrl'] === req.query.parentUrl);
+    }
+    return false;
+}

wmglobalqueue-2.4.5.1.data/data/data/couchapps/WorkQueue/language

@@ -0,0 +1 @@
+javascript

wmglobalqueue-2.4.5.1.data/data/data/couchapps/WorkQueue/lib/mustache.js

@@ -0,0 +1,333 @@
+/*
+  mustache.js Logic-less templates in JavaScript
+
+  See http://mustache.github.com/ for more info.
+
+  https://github.com/janl/mustache.js/
+  Copied from above site
+*/
+
+var Mustache = function() {
+  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;
+        }
+      }
+
+      template = this.render_pragmas(template);
+      var html = this.render_section(template, context, partials);
+      if(in_recursion) {
+        return this.render_tags(html, context, partials, in_recursion);
+      }
+
+      this.render_tags(html, context, partials, in_recursion);
+    },
+
+    /*
+      Sends parsed lines
+    */
+    send: function(line) {
+      if(line != "") {
+        this.buffer.push(line);
+      }
+    },
+
+    /*
+      Looks for %PRAGMAS
+    */
+    render_pragmas: function(template) {
+      // no pragmas
+      if(!this.includes("%", template)) {
+        return template;
+      }
+
+      var that = this;
+      var regex = new RegExp(this.otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" +
+            this.ctag);
+      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 = this.trim(name);
+      if(!partials || partials[name] === undefined) {
+        throw({message: "unknown_partial '" + name + "'"});
+      }
+      if(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)) {
+        return template;
+      }
+
+      var that = this;
+      // CSW - Added "+?" so it finds the tighest bound, not the widest
+      var regex = new RegExp(this.otag + "(\\^|\\#)\\s*(.+)\\s*" + this.ctag +
+              "\n*([\\s\\S]+?)" + this.otag + "\\/\\s*\\2\\s*" + this.ctag +
+              "\\s*", "mg");
+
+      // for each {{#foo}}{{/foo}} section do...
+      return template.replace(regex, function(match, type, name, content) {
+        var value = that.find(name, context);
+        if(type == "^") { // inverted section
+          if(!value || that.is_array(value) && value.length === 0) {
+            // false or empty list, render it
+            return that.render(content, context, partials, true);
+          } else {
+            return "";
+          }
+        } else if(type == "#") { // normal section
+          if(that.is_array(value)) { // Enumerable, Let's loop!
+            return 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!
+            return that.render(content, that.create_context(value),
+              partials, true);
+          } else if(typeof value === "function") {
+            // higher order section
+            return value.call(context, content, function(text) {
+              return that.render(text, context, partials, true);
+            });
+          } else if(value) { // boolean section
+            return that.render(content, context, partials, true);
+          } else {
+            return "";
+          }
+        }
+      });
+    },
+
+    /*
+      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 new RegExp(that.otag + "(=|!|>|\\{|%)?([^\\/#\\^]+?)\\1?" +
+          that.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
+          return that.find(name, context);
+        default: // escape the value
+          return that.escape(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 = this.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;
+      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 "";
+    },
+
+    // Utility methods
+
+    /* includes tag */
+    includes: function(needle, haystack) {
+      return haystack.indexOf(this.otag + needle) != -1;
+    },
+
+    /*
+      Does away with nasty characters
+    */
+    escape: function(s) {
+      s = String(s === null ? "" : s);
+      return s.replace(/&(?!\w+;)|["'<>\\]/g, function(s) {
+        switch(s) {
+        case "&": return "&amp;";
+        case "\\": return "\\\\";
+        case '"': return '&quot;';
+        case "'": return '&#39;';
+        case "<": return "&lt;";
+        case ">": return "&gt;";
+        default: return s;
+        }
+      });
+    },
+
+    // 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";
+    },
+
+    is_array: function(a) {
+      return Object.prototype.toString.call(a) === '[object Array]';
+    },
+
+    /*
+      Gets rid of leading and trailing whitespace
+    */
+    trim: function(s) {
+      return s.replace(/^\s*|\s*$/g, "");
+    },
+
+    /*
+      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;
+      }
+    }
+  };
+
+  return({
+    name: "mustache.js",
+    version: "0.3.1-dev",
+
+    /*
+      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");
+      }
+    }
+  });
+}();
+// for CommonJS
+if (exports) {
+  exports.to_html = Mustache.to_html;
+  exports.escape = Mustache.escape;
+};

wmglobalqueue-2.4.5.1.data/data/data/couchapps/WorkQueue/lib/validate.js

@@ -0,0 +1,27 @@
+// Idea from https://github.com/jchris/couchapp.org
+
+exports.init = function(newDoc, oldDoc, userCtx) {
+    var v = {};
+
+    // Is this an admin
+    v.isAdmin = function() {
+	    return userCtx.roles.indexOf('_admin') !== -1;
+    };
+
+    // Does person have the required role for the required group
+    v.hasGroupRole = function(group, role) {
+        for(var i = 0, l = userCtx.roles.length; i < l; i++) {
+            var user_role = userCtx.roles[i][0];
+            if (user_role === role) {
+                var user_groups = userCtx.roles[i][1];
+                if (user_groups.indexOf('group:' + group) !== -1) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+
+
+    return v;
+};

wmglobalqueue-2.4.5.1.data/data/data/couchapps/WorkQueue/lib/workqueue_utils.js

@@ -0,0 +1,61 @@
+// Useful functions for workqueue couchapp
+
+var workqueue_utils = {
+
+	commonInputDataSites: function(element) {
+		// Determine sites which contain all the input data
+		if (element["NoInputUpdate"] === true) {
+			return element["SiteWhitelist"];
+		}
+		return this.commonSites(element, "Inputs");
+	},
+
+	commonInputParentDataSites: function(element) {
+		// Determine sites which contain all the input parent data
+		if (element["NoInputUpdate"] === true) {
+			return element["SiteWhitelist"];
+		}
+		return this.commonSites(element, "ParentData");
+	},
+
+	commonPileupDataSites: function(element) {
+		// Determine sites which contain something of the pileup data
+		if (element["NoPileupUpdate"] === true) {
+			return element["SiteWhitelist"];
+		}
+        return this.commonSites(element, "PileupData");
+	},
+
+	commonSites: function(element, label) {
+	    // just need to find ONE common site
+		var site_white_list = element["SiteWhitelist"];
+		for (var data in element[label]) {
+			var common_sites = [];
+			if (!element[label][data].length) {
+				// input data has no locations
+				return common_sites;
+			}
+			var locations = element[label][data];
+			// remove any site that doesnt host a data item
+			for (var i = 0; i < locations.length; i++) {
+				if (site_white_list.indexOf(locations[i]) > -1) {
+					common_sites.push(locations[i]);
+					break;
+				}
+			}
+			if (!common_sites.length) {
+				return common_sites;
+			}
+		}
+		// everything is fine then
+		return site_white_list;
+	},
+
+};
+
+//CommonJS bindings
+if( typeof(exports) === 'object' ) {
+	exports.commonInputDataSites = workqueue_utils.commonInputDataSites;
+	exports.commonInputParentDataSites = workqueue_utils.commonInputParentDataSites;
+	exports.commonPileupDataSites = workqueue_utils.commonPileupDataSites;
+};

wmglobalqueue-2.4.5.1.data/data/data/couchapps/WorkQueue/lists/elementsDetail.js

@@ -0,0 +1,28 @@
+function(head, req) {
+    // this function is used for elementsDetailByWorkflowAndStatus
+    var mainDoc = this;
+    provides("html", function() {
+        var Mustache = require("lib/mustache");
+        var requestInfo;
+        if (req.query.startkey) {
+            requestInfo = {request: req.query.startkey[0]};
+        } else {
+            requestInfo = {request: ""};
+        }
+        return Mustache.to_html(mainDoc.templates.ElementSummaryByWorkflow,
+                                requestInfo, mainDoc.templates.partials, send);
+    });
+
+    provides("json", function() {
+        send("[");
+        var row = getRow();
+        if (row) {
+            send(toJSON(row.value));
+            while (row = getRow()){
+                send(",");
+                send(toJSON(row.value));
+            }
+        }// end rows
+        send("]");
+    });
+}; // end function

wmglobalqueue-2.4.5.1.data/data/data/couchapps/WorkQueue/lists/filter.js

@@ -0,0 +1,86 @@
+function(head, req) {
+
+	// Return elements, in json list, that match given criteria
+	// Optionally, return id of matching elements only
+
+	if (!req.query.filter) {
+		send('"Filter parameters required"');
+		return;
+	}
+	var query = JSON.parse(req.query.filter);
+	var idOnly = JSON.parse(req.query.idOnly);
+
+	send("[");
+	var first = true;
+	while (row = getRow()) {
+		
+		//in case document is already deleted	
+		if (!row.doc) {
+			continue;
+		};
+		
+		ele = row["doc"]["WMCore.WorkQueue.DataStructs.WorkQueueElement.WorkQueueElement"];
+		// is this an element
+		if (!ele) {
+			continue;
+		}
+
+		var matched = true;
+		for (key in query) {
+
+			if (key === 'since' && query[key] > row.timestamp) {
+				matched = false;
+				break;
+			}
+	
+			if (key === 'after' && query[key] < row.timestamp) {
+				matched = false;
+				break;
+			}
+			
+			if (key === 'reqMgrUpdateNeeded' && query[key] === 'true') {
+				if (row.updatetime > row.reqmgrupdatetime) {
+					matched = false;
+					break;
+				}
+			}
+
+            // if element doesnt have the key it cant match
+			if (!ele.hasOwnProperty(key)) {
+				matched = false;
+				break;
+			}
+
+			// if array check if inside - can't believe this is the best way...
+			if (Object.prototype.toString.call(query[key]) === '[object Array]') {
+				if (query[key].indexOf(ele[key]) === -1) {
+				  matched = false;
+				  break;
+			    }
+
+			// for any other key just do a straight comparison
+			} else if (query[key] !== ele[key]) {
+				matched = false;
+				break;
+			}
+		}
+
+		if (!matched) {
+			continue // element doesn't fit requirements
+		}
+
+		if (first != true) {
+  		  send(",")
+  	  	}
+
+		// Send element or id depending on what was asked
+		if (idOnly) {
+			send(toJSON(row['id']));
+		} else {
+			send(toJSON(row["doc"]));  // need whole document, id etc...
+		}
+		first = false; // from now on prepend "," to output
+	}
+
+	send("]");	
+}

wmglobalqueue-2.4.5.1.data/data/data/couchapps/WorkQueue/lists/stuckElements.js

@@ -0,0 +1,38 @@
+function(head, req) {
+    // return elements that cannot be run
+    var mainDoc = this
+
+    provides("html", function() {
+        var Mustache = require("lib/mustache");
+        return Mustache.to_html(mainDoc.templates.StuckElementSummary,
+                                {}, mainDoc.templates.partials, send);
+    });
+
+    
+    provides("json", function() {
+        send("[");
+        var row = getRow();
+        if (row) {
+        	var ele = row['doc']['WMCore.WorkQueue.DataStructs.WorkQueueElement.WorkQueueElement'];
+        	ele.InsertTime = row['doc'].timestamp;
+        	ele.UpdateTime = row['doc'].updatetime;
+        	ele.reason = row['key'];
+        	ele.id = row['id'];
+        	send(toJSON(ele));
+            while (row = getRow()) {
+                //in case document is already deleted	
+                if (!row.doc) {
+                	continue;
+                };
+                send(",");
+                var ele = row['doc']['WMCore.WorkQueue.DataStructs.WorkQueueElement.WorkQueueElement'];
+                ele.InsertTime = row['doc'].timestamp;
+                ele.UpdateTime = row['doc'].updatetime;
+                ele.reason = row['key'];
+                ele.id = row['id'];
+                send(toJSON(ele));
+            };
+        }// end rows
+        send("]");
+    });
+}; // end function