Merge branch 'master' into master-redesign

Conflicts:
	app/views/project/list.jade
	public/coffee/list.coffee
	public/stylesheets/less/list.less
	public/stylesheets/less/style.less

services/web/Gruntfile.coffee

@@ -80,6 +80,9 @@ module.exports = (grunt) ->
 		requirejs:
 			compile:
 				options:
+					optimize:"uglify2"
+					uglify2:
+						mangle: false
 					appDir: "public/js"
 					baseUrl: "./"
 					dir: "public/minjs"

services/web/app/coffee/Features/Editor/EditorController.coffee

@@ -256,7 +256,6 @@ module.exports = EditorController =
 	renameProject: (project_id, newName, callback)->
 		newName = sanitize.escape(newName)
 		ProjectDetailsHandler.renameProject project_id, newName, =>
-			newName = sanitize.escape(newName)
 			EditorRealTimeController.emitToRoom project_id, 'projectNameUpdated', newName
 			callback?()
 

services/web/app/coffee/Features/User/UserInfoController.coffee

@@ -1,24 +1,42 @@
 UserGetter = require "./UserGetter"
 logger = require("logger-sharelatex")
 UserDeleter = require("./UserDeleter")
+UserUpdater = require("./UserUpdater")
+sanitize = require('sanitizer')
 
 module.exports = UserController =
 	getLoggedInUsersPersonalInfo: (req, res, next = (error) ->) ->
 		# this is funcky as hell, we don't use the current session to get the user
 		# we use the auth token, actually destroying session from the chat api request
-		req.session.destroy() 
+		if req.query?.auth_token?
+			req.session.destroy() 
 		logger.log user: req.user, "reciving request for getting logged in users personal info"
 		return next(new Error("User is not logged in")) if !req.user?
-		UserController.sendFormattedPersonalInfo(req.user, res, next)
+		UserGetter.getUser req.session.user._id, { first_name: true, last_name: true, role:true, institution:true }, (error, user) ->
+			UserController.sendFormattedPersonalInfo(user, res, next)
 
 	getPersonalInfo: (req, res, next = (error) ->) ->
-		UserGetter.getUser req.params.user_id, { _id: true, first_name: true, last_name: true, email: true }, (error, user) ->
-			logger.log user: req.params.user_id, "reciving request for getting users personal info"
+		UserGetter.getUser req.params.user_id, { _id: true, first_name: true, last_name: true, email: true}, (error, user) ->
+			logger.log user_id: req.params.user_id, "reciving request for getting users personal info"
 			return next(error) if error?
 			return res.send(404) if !user?
 			UserController.sendFormattedPersonalInfo(user, res, next)
 			req.session.destroy()
 
+	updatePersonalInfo: (req, res, next = (error)->) ->
+		{first_name, last_name, role, institution} = req.body
+		user_id = req.session.user._id
+		logger.log data:req.body, user_id:user_id, "getting update for user personal info"
+		update = 
+			first_name:sanitize.escape(first_name)
+			last_name:sanitize.escape(last_name)
+			role:sanitize.escape(role)
+			institution:sanitize.escape(institution)
+		UserUpdater.updatePersonalInfo user_id, update, (err)->
+			if err?
+				res.send 500
+			else
+				res.send 204
 
 	sendFormattedPersonalInfo: (user, res, next = (error) ->) ->
 		UserController._formatPersonalInfo user, (error, info) ->
@@ -32,6 +50,8 @@ module.exports = UserController =
 			last_name: user.last_name
 			email: user.email
 			signUpDate: user.signUpDate
+			role: user.role
+			institution: user.institution
 		}
 		
 

services/web/app/coffee/Features/User/UserUpdater.coffee

@@ -28,3 +28,14 @@ module.exports = UserUpdater =
 					return callback(err)
 				callback()
 
+
+	updatePersonalInfo: (user_id, info, callback)->
+		self = @
+		update = 
+			$set: 
+				"first_name": info.first_name || ""
+				"last_name":  info.last_name || ""
+				"role":		  info.role || ""
+				"institution": info.institution || ""
+		self.updateUser user_id.toString(), update, (err)->
+			callback(err)

services/web/app/coffee/models/User.coffee

@@ -10,6 +10,8 @@ UserSchema = new Schema
 	email             : {type : String, default : ''}
 	first_name        : {type : String, default : ''}
 	last_name         : {type : String, default : ''}
+	role  	          : {type : String, default : ''}
+	institution       : {type : String, default : ''}
 	hashedPassword    : String
 	isAdmin           : {type : Boolean, default : false}
 	confirmed         : {type : Boolean, default : false}

services/web/app/coffee/router.coffee

@@ -91,8 +91,9 @@ module.exports = class Router
 
 		app.get  '/user/auth_token', AuthenticationController.requireLogin(), AuthenticationController.getAuthToken
 		app.get  '/user/personal_info', AuthenticationController.requireLogin(allow_auth_token: true), UserInfoController.getLoggedInUsersPersonalInfo
+		app.post  '/user/personal_info', AuthenticationController.requireLogin(), UserInfoController.updatePersonalInfo
 		app.get  '/user/:user_id/personal_info', httpAuth, UserInfoController.getPersonalInfo
-		
+
 		app.get  '/project', AuthenticationController.requireLogin(), ProjectController.projectListPage
 		app.post '/project/new', AuthenticationController.requireLogin(), ProjectController.newProject
 

services/web/public/coffee/UserDetailsUpdater.coffee

@@ -0,0 +1,61 @@
+define ["libs/algolia", "libs/angular", "libs/angular-autocomplete/angular-autocomplete"], (algolia)->
+
+	app = angular.module("userProfileInformationApp", ["autocomplete"])
+
+	app.factory "Institutions", ->
+		new AlgoliaSearch("SK53GL4JLY", "1606ccef5b70ac44680b61e6b0285126").initIndex("institutions")
+
+	app.directive "focusInput", ($timeout) ->
+		return (scope, element, attr) ->
+			scope.$watch attr.focusInput, (value) ->
+				if value
+					$timeout ->
+						element.select()
+
+	app.controller "UpdateForm", ($scope, $http, Institutions)->
+		$scope.institutions = []
+		$scope.formVisable = false
+		$scope.hidePersonalInfoSection = true
+		$scope.roles = ["Student", "Post-graduate student", "Post-doctoral researcher", "Lecturer", "Professor"]
+
+		$http.get("/user/personal_info").success (data)->
+			$scope.userInfoForm =
+				first_name: data.first_name
+				last_name: data.last_name
+				role: 	   data.role
+				institution: data.institution
+				_csrf : window.csrfToken
+
+			if getPercentComplete() != 100
+				$scope.percentComplete = getPercentComplete()
+				$scope.hidePersonalInfoSection = false
+
+		$scope.showForm = ->
+			$scope.formVisable = true
+
+		$scope.sendUpdate = ->
+			request = $http.post "/user/personal_info", $scope.userInfoForm
+			request.success (data, status)->
+			request.error (data, status)->
+				console.log "the request failed"
+			$scope.percentComplete = getPercentComplete()
+
+		getPercentComplete = ->
+			results = _.filter $scope.userInfoForm, (value)-> value? and value?.length != 0
+			results.length * 20
+
+		$scope.updateInstitutionsList = (inputVal)->
+
+			# this is a little hack to use until we change auto compelete lib with redesign and can 
+			# listen for blur events on institution field to send the post
+			if inputVal?.indexOf("(") != -1 and inputVal?.indexOf(")") != -1 
+				$scope.sendUpdate()
+				
+			Institutions.search $scope.userInfoForm.institution, (err, response)->
+				$scope.institutions = _.map response.hits, (institution)->
+					"#{institution.name} (<span class='muted'>#{institution.domain}</span>)"
+
+
+
+	angular.bootstrap(document.getElementById("userProfileInformation"), ['userProfileInformationApp'])
+

services/web/public/js/libs/angular-autocomplete/ac_template.html

@@ -0,0 +1,18 @@
+<div class="autocomplete {{ attrs.class }}" id="{{ attrs.id }}">
+  <input
+    type="text"
+    ng-model="searchParam"
+    placeholder="{{ attrs.placeholder }}"
+    class="{{ attrs.inputclass }}"
+    id="{{ attrs.inputid }}"/>
+  <ul ng-show="completing">
+    <li
+      suggestion
+      ng-repeat="suggestion in suggestions | filter:searchFilter | orderBy:'toString()' track by $index"
+      index="{{ $index }}"
+      val="{{ suggestion }}"
+      ng-class="{ active: ($index === selectedIndex) }"
+      ng-click="select(suggestion)"
+      ng-bind-html="suggestion | highlight:searchParam"></li>
+  </ul>
+</div>

services/web/public/js/libs/angular-autocomplete/angular-autocomplete.js

@@ -0,0 +1,264 @@
+/* --- Made by justgoscha and licensed under MIT license --- */
+
+define(["libs/angular"], function(){
+
+
+
+var app = angular.module('autocomplete', []);
+
+app.directive('autocomplete', function() {
+  var index = -1;
+
+  return {
+    restrict: 'E',
+    scope: {
+      searchParam: '=ngModel',
+      suggestions: '=data',
+      onType: '=onType',
+      onSelect: '=onSelect'
+    },
+    controller: ['$scope', function($scope){
+      // the index of the suggestions that's currently selected
+      $scope.selectedIndex = -1;
+
+      // set new index
+      $scope.setIndex = function(i){
+        $scope.selectedIndex = parseInt(i);
+      };
+
+      this.setIndex = function(i){
+        $scope.setIndex(i);
+        $scope.$apply();
+      };
+
+      $scope.getIndex = function(i){
+        return $scope.selectedIndex;
+      };
+
+      // watches if the parameter filter should be changed
+      var watching = true;
+
+      // autocompleting drop down on/off
+      $scope.completing = false;
+
+      // starts autocompleting on typing in something
+      $scope.$watch('searchParam', function(newValue, oldValue){
+        if (oldValue === newValue) {
+          return;
+        }
+
+        if(watching && $scope.searchParam) {
+          $scope.completing = true;
+          $scope.searchFilter = $scope.searchParam;
+          $scope.selectedIndex = -1;
+        }
+
+        // function thats passed to on-type attribute gets executed
+        if($scope.onType)
+          $scope.onType($scope.searchParam);
+      });
+
+      // for hovering over suggestions
+      this.preSelect = function(suggestion){
+
+        watching = false;
+
+        // this line determines if it is shown
+        // in the input field before it's selected:
+        //$scope.searchParam = suggestion;
+
+        $scope.$apply();
+        watching = true;
+
+      };
+
+      $scope.preSelect = this.preSelect;
+
+      this.preSelectOff = function(){
+        watching = true;
+      };
+
+      $scope.preSelectOff = this.preSelectOff;
+
+      // selecting a suggestion with RIGHT ARROW or ENTER
+      $scope.select = function(suggestion){
+        if(suggestion){
+          $scope.searchParam = suggestion;
+          $scope.searchFilter = suggestion;
+          if($scope.onSelect)
+            $scope.onSelect(suggestion);
+        }
+        watching = false;
+        $scope.completing = false;
+        setTimeout(function(){watching = true;},1000);
+        $scope.setIndex(-1);
+      };
+
+
+    }],
+    link: function(scope, element, attrs){
+
+      var attr = '';
+
+      // Default atts
+      scope.attrs = {
+        "placeholder": "start typing...",
+        "class": "",
+        "id": "",
+        "inputclass": "",
+        "inputid": ""
+      };
+
+      for (var a in attrs) {
+        attr = a.replace('attr', '').toLowerCase();
+        // add attribute overriding defaults
+        // and preventing duplication
+        if (a.indexOf('attr') === 0) {
+          scope.attrs[attr] = attrs[a];
+        }
+      }
+
+      if (attrs.clickActivation) {
+        element[0].onclick = function(e){
+          if(!scope.searchParam){
+            scope.completing = true;
+            scope.$apply();
+          }
+        };
+      }
+
+      var key = {left: 37, up: 38, right: 39, down: 40 , enter: 13, esc: 27};
+
+      document.addEventListener("keydown", function(e){
+        var keycode = e.keyCode || e.which;
+
+        switch (keycode){
+          case key.esc:
+            // disable suggestions on escape
+            scope.select();
+            scope.setIndex(-1);
+            scope.$apply();
+            e.preventDefault();
+        }
+      }, true);
+
+      document.addEventListener("blur", function(e){
+        // disable suggestions on blur
+        // we do a timeout to prevent hiding it before a click event is registered
+        setTimeout(function() {
+          scope.select();
+          scope.setIndex(-1);
+          scope.$apply();
+        }, 200);
+      }, true);
+
+      element[0].addEventListener("keydown",function (e){
+        var keycode = e.keyCode || e.which;
+
+        var l = angular.element(this).find('li').length;
+
+        // implementation of the up and down movement in the list of suggestions
+        switch (keycode){
+          case key.up:
+
+            index = scope.getIndex()-1;
+            if(index<-1){
+              index = l-1;
+            } else if (index >= l ){
+              index = -1;
+              scope.setIndex(index);
+              scope.preSelectOff();
+              break;
+            }
+            scope.setIndex(index);
+
+            if(index!==-1)
+              scope.preSelect(angular.element(angular.element(this).find('li')[index]).text());
+
+            scope.$apply();
+
+            break;
+          case key.down:
+            index = scope.getIndex()+1;
+            if(index<-1){
+              index = l-1;
+            } else if (index >= l ){
+              index = -1;
+              scope.setIndex(index);
+              scope.preSelectOff();
+              scope.$apply();
+              break;
+            }
+            scope.setIndex(index);
+
+            if(index!==-1)
+              scope.preSelect(angular.element(angular.element(this).find('li')[index]).text());
+
+            break;
+          case key.left:
+            break;
+          case key.right:
+          case key.enter:
+
+            index = scope.getIndex();
+            // scope.preSelectOff();
+            if(index !== -1)
+              scope.select(angular.element(angular.element(this).find('li')[index]).text());
+            scope.setIndex(-1);
+            scope.$apply();
+
+            break;
+          case key.esc:
+            // disable suggestions on escape
+            scope.select();
+            scope.setIndex(-1);
+            scope.$apply();
+            e.preventDefault();
+            break;
+          default:
+            return;
+        }
+
+        if(scope.getIndex()!==-1 || keycode == key.enter)
+          e.preventDefault();
+      });
+    },
+    templateUrl: 'js/libs/angular-autocomplete/ac_template.html'
+  };
+});
+
+app.filter('highlight', ['$sce', function ($sce) {
+  return function (input, searchParam) {
+    if (typeof input === 'function') return '';
+    if (searchParam) {
+      var words = '(' +
+            searchParam.split(/\ /).join(' |') + '|' +
+            searchParam.split(/\ /).join('|') +
+          ')',
+          exp = new RegExp(words, 'gi');
+      if (words.length) {
+        input = input.replace(exp, "<span class=\"highlight\">$1</span>");
+      }
+    }
+    return $sce.trustAsHtml(input);
+  };
+}]);
+
+app.directive('suggestion', function(){
+  return {
+    restrict: 'A',
+    require: '^autocomplete', // ^look for controller on parents element
+    link: function(scope, element, attrs, autoCtrl){
+      element.bind('mouseenter', function() {
+        autoCtrl.preSelect(attrs.val);
+        autoCtrl.setIndex(attrs.index);
+      });
+
+      element.bind('mouseleave', function() {
+        autoCtrl.preSelectOff();
+      });
+    }
+  };
+});
+
+})

services/web/test/UnitTests/coffee/User/UserInfoControllerTests.coffee

@@ -1,5 +1,6 @@
 sinon = require('sinon')
 chai = require('chai')
+assert = require("chai").assert
 should = chai.should()
 expect = chai.expect
 modulePath = "../../../../app/js/Features/User/UserInfoController.js"
@@ -13,9 +14,15 @@ describe "UserInfoController", ->
 	beforeEach ->
 		@UserDeleter = 
 			deleteUser: sinon.stub().callsArgWith(1)
+		@UserUpdater = 
+			updatePersonalInfo: sinon.stub()
+		@sanitizer = escape:(v)->v
+		sinon.spy @sanitizer, "escape"
 		@UserInfoController = SandboxedModule.require modulePath, requires:
 			"./UserGetter": @UserGetter = {}
+			"./UserUpdater": @UserUpdater
 			"./UserDeleter": @UserDeleter
+			"sanitizer":@sanitizer
 
 		@req = new MockRequest()
 		@res = new MockResponse()
@@ -107,4 +114,51 @@ describe "UserInfoController", ->
 					signUpDate: @user.signUpDate
 				}
 
+	describe "setPersonalInfo", ->
+
+		beforeEach ->
+			@req = 
+				session:
+					user:
+						_id:"123123j321jikuj90jlk"
+			@req.body = 
+				first_name: "bob"
+				last_name: "smith"
+				role:"student"
+				institution: "Sheffield"
+				notWanted: "something"
+
+		it "should send the data from the body to the user updater", (done)->
+
+			@UserUpdater.updatePersonalInfo.callsArgWith(2, null)
+			@res.send = (statusCode)=>
+				statusCode.should.equal 204
+				@UserUpdater.updatePersonalInfo.args[0][0].should.equal @req.session.user._id
+				args = @UserUpdater.updatePersonalInfo.args[0][1]
+				args.first_name.should.equal @req.body.first_name
+				args.last_name.should.equal @req.body.last_name
+				args.role.should.equal @req.body.role
+				args.institution.should.equal @req.body.institution
+				assert.equal args.notWanted, undefined
+				done()
+
+			@UserInfoController.updatePersonalInfo @req, @res
+
+		it "should sanitize the data", (done)->
+			@UserUpdater.updatePersonalInfo.callsArgWith(2, null)
+			@res.send = (statusCode)=>
+				@sanitizer.escape.calledWith(@req.body.first_name).should.equal true
+				@sanitizer.escape.calledWith(@req.body.last_name).should.equal true
+				@sanitizer.escape.calledWith(@req.body.role).should.equal true
+				@sanitizer.escape.calledWith(@req.body.institution).should.equal true
+				done()
+			@UserInfoController.updatePersonalInfo @req, @res
+
+		it "should send an error if the UpserUpdater returns on", (done)->
+			@UserUpdater.updatePersonalInfo.callsArgWith(2, "error")
+			@res.send = (statusCode)->
+				statusCode.should.equal 500
+				done()
+			@UserInfoController.updatePersonalInfo @req, @res
+
 

services/web/test/UnitTests/coffee/User/UserUpdaterTests.coffee

@@ -45,3 +45,40 @@ describe "UserUpdater", ->
 			@UserUpdater.changeEmailAddress @user_id, @newEmail, (err)=>
 				@UserUpdater.updateUser.calledWith(@user_id, $set: { "email": @newEmail}).should.equal true
 				done()
+
+	describe "updatePersonalInfo", ->
+
+		beforeEach ->
+			@info =
+				first_name:"billy"
+				last_name:"brag"
+				role:"student"
+				institution:"sheffield"
+
+		it "should set the names role and institution", (done)->
+			@UserUpdater.updateUser = sinon.stub().callsArgWith(2)
+			@UserUpdater.updatePersonalInfo @user_id, @info, (err)=>
+				@UserUpdater.updateUser.args[0][0].should.equal @user_id
+				args = @UserUpdater.updateUser.args[0][1]
+				args["$set"].first_name.should.equal @info.first_name
+				args["$set"].last_name.should.equal @info.last_name
+				args["$set"].role.should.equal @info.role
+				args["$set"].institution.should.equal @info.institution
+				done()
+
+		it "should return the error", (done)->
+			@UserUpdater.updateUser = sinon.stub().callsArgWith(2, "error")
+			@UserUpdater.updatePersonalInfo @user_id, @info, (err)=>
+				should.exist(err)
+				done()
+
+		it "should default them to empty strings", (done)->
+			@UserUpdater.updateUser = sinon.stub().callsArgWith(2)
+			@UserUpdater.updatePersonalInfo @user_id, {}, (err)=>
+				args = @UserUpdater.updateUser.args[0][1]
+				args["$set"].first_name.should.equal ""
+				args["$set"].last_name.should.equal ""
+				args["$set"].role.should.equal ""
+				args["$set"].institution.should.equal ""
+				done()
+