github/overleaf
1
0
Fork 0
mirror of https://github.com/overleaf/overleaf.git synced 2024-11-07 20:31:06 -05:00
Code Issues Projects Releases Packages Wiki Activity

started using underscore.string to check domain emails

Browse source
This commit is contained in:
Henry Oswald 2015-02-02 11:15:04 +00:00
parent 0a64c1c8ac
commit ee83ed6e81
3 changed files with 279 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
services/web/app/coffee/Features/Subscription/SubscriptionDomainAllocator.coffee
View file

@ -1,7 +1,8 @@
async = require("async")
_ = require("lodash")
_ = require("underscore")
settings = require("settings-sharelatex")
SubscriptionGroupHandler = require("./SubscriptionGroupHandler")
_s = require("underscore.string")
module.exports = SubscriptionDomainAllocator =
@ -16,7 +17,7 @@ module.exports = SubscriptionDomainAllocator =
_findDomainLicence: (email)->
licence = _.find settings.domainLicences, (licence)->
_.find licence.domains, (domain)->
_.includes email, domain
_s.endsWith email, domain
return licence

2
services/web/package.json
View file

@ -19,7 +19,6 @@
"express": "3.3.4",
"fairy": "0.0.2",
"jade": "~1.3.1",
"lodash": "3.0.0",
"logger-sharelatex": "git+https://github.com/sharelatex/logger-sharelatex.git#v1.0.0",
"lynx": "0.1.1",
"metrics-sharelatex": "git+https://github.com/sharelatex/metrics-sharelatex.git#v1.0.0",
@ -41,6 +40,7 @@
"socket.io": "0.9.16",
"translations-sharelatex": "git+https://github.com/sharelatex/translations-sharelatex.git#master",
"underscore": "1.6.0",
"underscore.string": "^3.0.2",
"xml2js": "0.2.0"
},
"devDependencies": {

282
services/web/public/js/libs/jquery-layout.js vendored
View file

@ -1,3 +1,270 @@
// (function(LST) {
// LST.rethrow = false;
// var currentTraceError = null;
// var filename = new Error().stack.split("\n")[1].match(/^ at ((?:\w+:\/\/)?[^:]+)/)[1];
// function filterInternalFrames(frames) {
// return frames.split("\n").filter(function(frame) { return frame.indexOf(filename) < 0; }).join("\n");
// }
// Error.prepareStackTrace = function(error, structuredStackTrace) {
// if (!error.__cachedTrace) {
// error.__cachedTrace = filterInternalFrames(FormatStackTrace(error, structuredStackTrace));
// if (!has.call(error, "__previous")) {
// var previous = currentTraceError;
// while (previous) {
// var previousTrace = previous.stack;
// error.__cachedTrace += "\n----------------------------------------\n" +
// " at " + previous.__location + "\n" +
// previousTrace.substring(previousTrace.indexOf("\n") + 1);
// previous = previous.__previous;
// }
// }
// }
// return error.__cachedTrace;
// }
// var slice = Array.prototype.slice;
// var has = Object.prototype.hasOwnProperty;
// // Takes an object, a property name for the callback function to wrap, and an argument position
// // and overwrites the function with a wrapper that captures the stack at the time of callback registration
// function wrapRegistrationFunction(object, property, callbackArg) {
// if (typeof object[property] !== "function") {
// console.error("(long-stack-traces) Object", object, "does not contain function", property);
// return;
// }
// if (!has.call(object, property)) {
// console.warn("(long-stack-traces) Object", object, "does not directly contain function", property);
// }
// // TODO: better source position detection
// var sourcePosition = (object.constructor.name || Object.prototype.toString.call(object)) + "." + property;
// // capture the original registration function
// var fn = object[property];
// // overwrite it with a wrapped registration function that modifies the supplied callback argument
// object[property] = function() {
// // replace the callback argument with a wrapped version that captured the current stack trace
// arguments[callbackArg] = makeWrappedCallback(arguments[callbackArg], sourcePosition);
// // call the original registration function with the modified arguments
// return fn.apply(this, arguments);
// }
// // check that the registration function was indeed overwritten
// if (object[property] === fn)
// console.warn("(long-stack-traces) Couldn't replace ", property, "on", object);
// }
// // Takes a callback function and name, and captures a stack trace, returning a new callback that restores the stack frame
// // This function adds a single function call overhead during callback registration vs. inlining it in wrapRegistationFunction
// function makeWrappedCallback(callback, frameLocation) {
// // add a fake stack frame. we can't get a real one since we aren't inside the original function
// var traceError = new Error();
// traceError.__location = frameLocation;
// traceError.__previous = currentTraceError;
// return function() {
// // if (currentTraceError) {
// // FIXME: This shouldn't normally happen, but it often does. Do we actually need a stack instead?
// // console.warn("(long-stack-traces) Internal Error: currentTrace already set.");
// // }
// // restore the trace
// currentTraceError = traceError;
// try {
// return callback.apply(this, arguments);
// } catch (e) {
// console.error("Uncaught " + e.stack);
// if (LST.rethrow)
// throw ""; // TODO: throw the original error, or undefined?
// } finally {
// // clear the trace so we can check that none is set above.
// // TODO: could we remove this for slightly better performace?
// currentTraceError = null;
// }
// }
// }
// // Chrome
// if (typeof window !== "undefined") {
// wrapRegistrationFunction(window.constructor.prototype, "setTimeout", 0);
// wrapRegistrationFunction(window.constructor.prototype, "setInterval", 0);
// [
// window.Node.prototype,
// window.MessagePort.prototype,
// window.SVGElementInstance.prototype,
// window.WebSocket.prototype,
// window.XMLHttpRequest.prototype,
// window.EventSource.prototype,
// window.XMLHttpRequestUpload.prototype,
// window.SharedWorker.prototype.__proto__,
// window.constructor.prototype,
// window.applicationCache.constructor.prototype
// ].forEach(function(object) {
// wrapRegistrationFunction(object, "addEventListener", 1);
// });
// // this actually captures the stack when "send" is called, which isn't ideal,
// // but it's the best we can do without hooking onreadystatechange assignments
// var _send = XMLHttpRequest.prototype.send;
// XMLHttpRequest.prototype.send = function() {
// this.onreadystatechange = makeWrappedCallback(this.onreadystatechange, "onreadystatechange");
// return _send.apply(this, arguments);
// }
// // FIXME: experimental XHR wrapper for hooking onreadystatechange
// // Based on https://gist.github.com/796032
// // var _XMLHttpRequest = XMLHttpRequest;
// // XMLHttpRequest = function () {
// // Object.defineProperty(this, "onreadystatechange", {
// // get: function() {
// // return this.__onreadystatechange;
// // },
// // set: function(onreadystatechange) {
// // if (this.__onreadystatechange && typeof this.__onreadystatechange.call === "function")
// // this.removeEventListener("readystatechange", this.__onreadystatechange);
// // this.__onreadystatechange = makeWrappedCallback(onreadystatechange, "onreadystatechange");
// // if (this.__onreadystatechange && typeof this.__onreadystatechange.call === "function")
// // this.addEventListener("readystatechange", this.__onreadystatechange);
// // },
// // enumerable: true
// // });
// // Object.defineProperty(this, "__onreadystatechange", {
// // value: null,
// // writable: true,
// // enumerable: false
// // });
// // }
// // XMLHttpRequest.prototype = new _XMLHttpRequest();
// }
// // Node.js
// else if (typeof process !== "undefined") {
// LST.rethrow = true;
// var global = (function() { return this; })();
// wrapRegistrationFunction(global, "setTimeout", 0);
// wrapRegistrationFunction(global, "setInterval", 0);
// wrapRegistrationFunction(global, "setImmediate", 0);
// var EventEmitter = require('events').EventEmitter;
// wrapRegistrationFunction(EventEmitter.prototype, "addListener", 1);
// wrapRegistrationFunction(EventEmitter.prototype, "on", 1);
// wrapRegistrationFunction(process, "nextTick", 0);
// }
// // Copyright 2006-2008 the V8 project authors. All rights reserved.
// // Redistribution and use in source and binary forms, with or without
// // modification, are permitted provided that the following conditions are
// // met:
// //
// // * Redistributions of source code must retain the above copyright
// // notice, this list of conditions and the following disclaimer.
// // * Redistributions in binary form must reproduce the above
// // copyright notice, this list of conditions and the following
// // disclaimer in the documentation and/or other materials provided
// // with the distribution.
// // * Neither the name of Google Inc. nor the names of its
// // contributors may be used to endorse or promote products derived
// // from this software without specific prior written permission.
// //
// // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// function FormatStackTrace(error, frames) {
// var lines = [];
// try {
// lines.push(error.toString());
// } catch (e) {
// try {
// lines.push("<error: " + e + ">");
// } catch (ee) {
// lines.push("<error>");
// }
// }
// for (var i = 0; i < frames.length; i++) {
// var frame = frames[i];
// var line;
// try {
// line = FormatSourcePosition(frame);
// } catch (e) {
// try {
// line = "<error: " + e + ">";
// } catch (ee) {
// // Any code that reaches this point is seriously nasty!
// line = "<error>";
// }
// }
// lines.push(" at " + line);
// }
// return lines.join("\n");
// }
// function FormatSourcePosition(frame) {
// var fileLocation = "";
// if (frame.isNative()) {
// fileLocation = "native";
// } else if (frame.isEval()) {
// fileLocation = "eval at " + frame.getEvalOrigin();
// } else {
// var fileName = frame.getFileName();
// if (fileName) {
// fileLocation += fileName;
// var lineNumber = frame.getLineNumber();
// if (lineNumber != null) {
// fileLocation += ":" + lineNumber;
// var columnNumber = frame.getColumnNumber();
// if (columnNumber) {
// fileLocation += ":" + columnNumber;
// }
// }
// }
// }
// if (!fileLocation) {
// fileLocation = "unknown source";
// }
// var line = "";
// var functionName = frame.getFunction().name;
// var addPrefix = true;
// var isConstructor = frame.isConstructor();
// var isMethodCall = !(frame.isToplevel() || isConstructor);
// if (isMethodCall) {
// var methodName = frame.getMethodName();
// line += frame.getTypeName() + ".";
// if (functionName) {
// line += functionName;
// if (methodName && (methodName != functionName)) {
// line += " [as " + methodName + "]";
// }
// } else {
// line += methodName || "<anonymous>";
// }
// } else if (isConstructor) {
// line += "new " + (functionName || "<anonymous>");
// } else if (functionName) {
// line += functionName;
// } else {
// line += fileLocation;
// addPrefix = false;
// }
// if (addPrefix) {
// line += " (" + fileLocation + ")";
// }
// return line;
// }
// })(typeof exports !== "undefined" ? exports : {});
/*! jQuery UI - v1.10.3 - 2013-10-24
* http://jqueryui.com
* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js
@ -4344,7 +4611,6 @@ $.fn.layout = function (opts) {
// first trigger the callback set in the options
if (fn) {
try {
// convert function name (string) to function object
if (isStr( fn )) {
if (fn.match(/,/)) {
@ -4366,12 +4632,10 @@ $.fn.layout = function (opts) {
else // must be a layout/container callback - pass suitable info
retVal = g(fn)( Instance, s, o, lName );
}
}
catch (ex) {
_log( options.errors.callbackError.replace(/EVENT/, $.trim((pane || "") +" "+ lng)), false );
if ($.type(ex) === 'string' && string.length)
_log('Exception: '+ ex, false );
}
// _log( options.errors.callbackError.replace(/EVENT/, $.trim((pane || "") +" "+ lng)), false );
// if ($.type(ex) === 'string' && string.length)
// _log('Exception: '+ ex, false );
}
// trigger additional events bound directly to the pane
@ -8234,6 +8498,7 @@ $.fn.layout = function (opts) {
* CREATE/RETURN LAYOUT
* #####################
*/
try {
// validate that container exists
var $N = $(this).eq(0); // FIRST matching Container element
@ -8245,6 +8510,9 @@ $.fn.layout = function (opts) {
// return the Instance-pointer if layout has already been initialized
if ($N.data("layoutContainer") && $N.data("layout"))
return $N.data("layout"); // cached pointer
} catch(e){
console.log("eeeee",e)
}
// init global vars
var