4 | These clients have no tasks
7 | These clients are calculating
8 |
9 |
10 |
34 |
35 |
--------------------------------------------------------------------------------
/.yo-rc.json:
--------------------------------------------------------------------------------
1 | {
2 | "generator-angular-fullstack": {
3 | "insertRoutes": true,
4 | "registerRoutesFile": "private/src/server/routes.js",
5 | "routesNeedle": "// Insert routes below",
6 | "routesBase": "/api/",
7 | "pluralizeRoutes": true,
8 | "insertSockets": true,
9 | "registerSocketsFile": "private/src/server/config/socketio.js",
10 | "socketsNeedle": "// Insert sockets below",
11 | "filters": {
12 | "js": true,
13 | "html": true,
14 | "css": true,
15 | "uirouter": true,
16 | "bootstrap": true,
17 | "uibootstrap": true,
18 | "socketio": true,
19 | "mongoose": true,
20 | "auth": true,
21 | "oauth": true,
22 | "googleAuth": true,
23 | "facebookAuth": true,
24 | "twitterAuth": true
25 | }
26 | },
27 | "generator-ng-component": {
28 | "routeDirectory": "private/src/client/app/",
29 | "directiveDirectory": "private/src/client/app/",
30 | "filterDirectory": "private/src/client/app/",
31 | "serviceDirectory": "private/src/client/app/",
32 | "basePath": "private/src/client",
33 | "filters": [
34 | "uirouter"
35 | ],
36 | "extensions": [
37 | "js",
38 | "html",
39 | "css"
40 | ]
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/public/static/js/script.js:
--------------------------------------------------------------------------------
1 | /* Author: YOUR NAME HERE
2 | */
3 |
4 | (function() {
5 |
6 | var ioClient = io.connect();
7 | var seq = 0;
8 |
9 | ioClient.on('task', function (serializedTask) {
10 | seq++;
11 | console.log(serializedTask);
12 | document.querySelector("#seq").textContent = seq;
13 | document.querySelector("#task").textContent = serializedTask;
14 | var task,
15 | response;
16 | try {
17 | task = JSON.parse(serializedTask, functionCreate);
18 | response = task.execute(_, task.data, task.callbacks).value();
19 | document.querySelector("#result").textContent = response;
20 | } catch (e) {
21 | console.log(e.toString());
22 | document.querySelector("#result").textContent = e.toString();
23 | }
24 | ioClient.emit('response', response.toString());
25 | console.log('Client response', response);
26 | });
27 |
28 | // CSP may block Function call, function used not to use eval
29 | function functionCreate(key, value) {
30 |
31 | if (!key) {
32 | return value;
33 | }
34 |
35 | if ('string' === typeof value) {
36 | var funcRegExp = /function[^\(]*\(([^\)]*)\)[^\{]*{([^\}]*)\}/,
37 | match = value.match(funcRegExp);
38 | if (match) {
39 | var args = match[1]
40 | .split(',')
41 | .map(function (arg) {
42 | return arg.replace(/\s+/, '');
43 | });
44 | return new Function(args, match[2]);
45 | }
46 | }
47 | return value;
48 | }
49 |
50 | })();
51 |
--------------------------------------------------------------------------------
/private/src/client/app/account/signup/signup.controller.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | angular.module('jsSparkUiApp')
4 | .controller('SignupCtrl', function ($scope, Auth, $location, $window) {
5 | $scope.user = {};
6 | $scope.errors = {};
7 |
8 | $scope.register = function (form) {
9 | $scope.submitted = true;
10 |
11 | if (form.$valid) {
12 | Auth.createUser({
13 | name: $scope.user.name,
14 | email: $scope.user.email,
15 | password: $scope.user.password
16 | })
17 | .then(function () {
18 | // Account created, redirect to home
19 | $location.path('/');
20 | })
21 | .catch(function (err) {
22 | err = err.data;
23 | $scope.errors = {};
24 |
25 | // Update validity of form fields that match the mongoose errors
26 | angular.forEach(err.errors, function (error, field) {
27 | form[field].$setValidity('mongoose', false);
28 | $scope.errors[field] = error.message;
29 | });
30 | });
31 | }
32 | };
33 |
34 | $scope.loginOauth = function (provider) {
35 | $window.location.href = '/auth/' + provider;
36 | };
37 | });
38 |
--------------------------------------------------------------------------------
/private/src/client/app/app.css:
--------------------------------------------------------------------------------
1 |
2 | /**
3 | * Bootstrap Fonts
4 | */
5 |
6 | @font-face {
7 | font-family: 'Glyphicons Halflings';
8 | src: url('../component/bootstrap/fonts/glyphicons-halflings-regular.eot');
9 | src: url('../component/bootstrap/fonts/glyphicons-halflings-regular.eot?#iefix') format('embedded-opentype'),
10 | url('../component/bootstrap/fonts/glyphicons-halflings-regular.woff') format('woff'),
11 | url('../component/bootstrap/fonts/glyphicons-halflings-regular.ttf') format('truetype'),
12 | url('../component/bootstrap/fonts/glyphicons-halflings-regular.svg#glyphicons_halflingsregular') format('svg');
13 | }
14 |
15 | /**
16 | *Font Awesome Fonts
17 | */
18 |
19 | @font-face {
20 | font-family: 'FontAwesome';
21 | src: url('../component/font-awesome/fonts/fontawesome-webfont.eot?v=4.1.0');
22 | src: url('../component/font-awesome/fonts/fontawesome-webfont.eot?#iefix&v=4.1.0') format('embedded-opentype'),
23 | url('../component/font-awesome/fonts/fontawesome-webfont.woff?v=4.1.0') format('woff'),
24 | url('../component/font-awesome/fonts/fontawesome-webfont.ttf?v=4.1.0') format('truetype'),
25 | url('../component/font-awesome/fonts/fontawesome-webfont.svg?v=4.1.0#fontawesomeregular') format('svg');
26 | font-weight: normal;
27 | font-style: normal;
28 | }
29 |
30 | /**
31 | * App-wide Styles
32 | */
33 |
34 | .browsehappy {
35 | margin: 0.2em 0;
36 | background: #ccc;
37 | color: #000;
38 | padding: 0.2em 0;
39 | }
40 |
--------------------------------------------------------------------------------
/private/src/server/auth/facebook/passport.js:
--------------------------------------------------------------------------------
1 | var passport = require('passport');
2 | var FacebookStrategy = require('passport-facebook').Strategy;
3 |
4 | exports.setup = function (User, config) {
5 | passport.use(new FacebookStrategy({
6 | clientID: config.facebook.clientID,
7 | clientSecret: config.facebook.clientSecret,
8 | callbackURL: config.facebook.callbackURL
9 | },
10 | function (accessToken, refreshToken, profile, done) {
11 | User.findOne({
12 | 'facebook.id': profile.id
13 | },
14 | function (err, user) {
15 | if (err) {
16 | return done(err);
17 | }
18 | if (!user) {
19 | user = new User({
20 | name: profile.displayName,
21 | email: profile.emails[0].value,
22 | role: 'user',
23 | username: profile.username,
24 | provider: 'facebook',
25 | facebook: profile._json
26 | });
27 | user.save(function (err) {
28 | if (err) done(err);
29 | return done(err, user);
30 | });
31 | } else {
32 | return done(err, user);
33 | }
34 | })
35 | }
36 | ));
37 | };
38 |
--------------------------------------------------------------------------------
/private/src/server/service/serializer.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Created by syzer on 7/24/2014.
3 | */
4 | module.exports = function serializerService(serializerInj) {
5 |
6 | var JSON = serializerInj || JSON;
7 | var LAME_ERROR = 'To unserialize please give a string';
8 |
9 | return {
10 |
11 | // serializes objects
12 | // TODO type check
13 | stringify: function (object) {
14 | return JSON.stringify(object, functionStringify);
15 | },
16 |
17 | parse: function (string) {
18 | if ('string' !== typeof string) {
19 | throw new Error(LAME_ERROR);
20 | }
21 | return JSON.parse(string, functionCreate);
22 | }
23 | };
24 |
25 | // JSON serializer helpers
26 | function functionStringify(key, value) {
27 | if ('function' === typeof(value)) {
28 | return value.toString();
29 | }
30 | return value;
31 | }
32 |
33 | function functionCreate(key, value) {
34 | if (!key) {
35 | return value;
36 | }
37 |
38 | if (typeof value === 'string') {
39 | var funcRegExp = /function[^\(]*\(([^\)]*)\)[^\{]*{([^\}]*)\}/,
40 | match = value.match(funcRegExp);
41 | if (match) {
42 | var args = match[1]
43 | .split(',')
44 | .map(function (arg) {
45 | return arg.replace(/\s+/, '');
46 | });
47 | return new Function(args, match[2]);
48 | }
49 | }
50 | return value;
51 | }
52 |
53 | };
54 |
--------------------------------------------------------------------------------
/private/src/client/app/account/login/login.controller.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | angular.module('jsSparkUiApp')
4 | .controller('LoginCtrl', function ($scope, Auth, $location, $window) {
5 |
6 | $scope.user = {password: '', email: ''};
7 | $scope.errors = {};
8 | $scope.cannotSubbmit = !$scope.user.password || !scope.user.email;
9 |
10 | $scope.login = function (form) {
11 | $scope.submitted = true;
12 |
13 | if (!form.$valid) {
14 | return;
15 | }
16 |
17 | Auth
18 | .login({
19 | email: $scope.user.email,
20 | password: $scope.user.password
21 | })
22 | .then(function () {
23 | // Logged in, redirect to Search
24 | $location.path('/search/');
25 | })
26 | .catch(function (err) {
27 | $scope.errors.other = err.message;
28 | });
29 | };
30 |
31 | $scope.loginOauth = function (provider) {
32 | $window.location.href = '/auth/' + provider;
33 | };
34 |
35 | // fix on change of user name if user had stored password then will auto fill password
36 | $scope.validateModel = function () {
37 | setTimeout(function () {
38 | $scope.$apply(function () {
39 | $scope.user.password = $('input[type=password]').val();
40 | $scope.cannotSubbmit = !$scope.user.password || !$scope.user.email;
41 | });
42 | }, 200);
43 | };
44 |
45 | });
46 |
--------------------------------------------------------------------------------
/private/src/server/app.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Main application file
3 | */
4 |
5 | 'use strict';
6 |
7 | // Set default node environment to development
8 | process.env.NODE_ENV = process.env.NODE_ENV || 'development';
9 |
10 | var express = require('express');
11 | var mongoose = require('mongoose');
12 | var config = require('./config/environment');
13 |
14 | // Connect to database
15 | mongoose.connect(config.mongo.uri, config.mongo.options);
16 |
17 | // Populate DB with sample data
18 | if (config.seedDB) {
19 | require('./config/seedDb');
20 | }
21 |
22 | // setup Dependencies
23 | var ROOT = './';
24 | var di = require(ROOT + 'controller/di')(
25 | require(ROOT + 'config/di').services
26 | );
27 |
28 | // Setup server
29 | var app = di.get('app');
30 | var server = di.get('server');
31 | var socketio = di.get('io.server');
32 | require('./config/express')(app);
33 | require('./routes')(app, di);
34 |
35 | // Start server
36 | server.listen(config.port, config.ip, function () {
37 | console.log('Express server listening on %d, in %s mode', config.port, app.get('env'));
38 | });
39 |
40 | // Expose app
41 | exports = module.exports = app;
42 |
43 | var _ = di.get('_');
44 | var jsSpark = di.get('service.jsSpark');
45 |
46 | setInterval(
47 | function delayedTask() {
48 | console.log('Sending task to calculate');
49 | jsSpark(_.range(1000))
50 | .filter(function isOdd(num) {
51 | return num % 2;
52 | })
53 | .reduce(function sumUp(sum, num) {
54 | return sum + num;
55 | })
56 | .run()
57 | .then(function (data) {
58 | console.log('Total sum of 1 to 1000 odd numbers is:', data);
59 | });
60 | }, 5000
61 | );
62 |
63 |
64 |
--------------------------------------------------------------------------------
/private/src/server/api/user/user.model.spec.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var should = require('should');
4 | var app = require('../../app');
5 | var User = require('./user.model');
6 |
7 | var user = new User({
8 | provider: 'local',
9 | name: 'Fake User',
10 | email: 'test@test.com',
11 | password: 'password'
12 | });
13 |
14 | describe('User Model', function () {
15 | before(function (done) {
16 | // Clear users before testing
17 | User.remove().exec().then(function () {
18 | done();
19 | });
20 | });
21 |
22 | afterEach(function (done) {
23 | User.remove().exec().then(function () {
24 | done();
25 | });
26 | });
27 |
28 | it('should begin with no users', function (done) {
29 | User.find({}, function (err, users) {
30 | users.should.have.length(0);
31 | done();
32 | });
33 | });
34 |
35 | it('should fail when saving a duplicate user', function (done) {
36 | user.save(function () {
37 | var userDup = new User(user);
38 | userDup.save(function (err) {
39 | should.exist(err);
40 | done();
41 | });
42 | });
43 | });
44 |
45 | it('should fail when saving without an email', function (done) {
46 | user.email = '';
47 | user.save(function (err) {
48 | should.exist(err);
49 | done();
50 | });
51 | });
52 |
53 | it("should authenticate user if password is valid", function () {
54 | user.authenticate('password').should.be.true;
55 | });
56 |
57 | it("should not authenticate user if password is invalid", function () {
58 | user.authenticate('blah').should.not.be.true;
59 | });
60 | });
61 |
--------------------------------------------------------------------------------
/private/src/client/app/account/settings/settings.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | Here are all clients that are connected:
5 | 6 || # | 12 |Id | 13 |IP | 15 |Free | 16 |Connected @ | 17 |Computing ques | 18 |Points | 19 ||
|---|---|---|---|---|---|---|---|
| {{$index+1}} | 24 |{{client._id}} | 25 |{{client.email}} | 26 |{{client.handshake.address}} | 27 |{{client.free|boolean}} | 28 |{{client.connectedAt|date : 'medium'}} | 29 |{{client.rooms|json}} | 30 |{{client.points}} | 31 |
4 |
44 |
--------------------------------------------------------------------------------
/private/src/client/components/navbar/navbar.html:
--------------------------------------------------------------------------------
1 |
31 |
--------------------------------------------------------------------------------
/protractor.conf.js:
--------------------------------------------------------------------------------
1 | // Protractor configuration
2 | // https://github.com/angular/protractor/blob/master/referenceConf.js
3 |
4 | 'use strict';
5 |
6 | exports.config = {
7 | // The timeout for each script run on the browser. This should be longer
8 | // than the maximum time your application needs to stabilize between tasks.
9 | allScriptsTimeout: 110000,
10 |
11 | // A base URL for your application under test. Calls to protractor.get()
12 | // with relative paths will be prepended with this.
13 | baseUrl: 'http://localhost:' + (process.env.PORT || '9000'),
14 |
15 | // If true, only chromedriver will be started, not a standalone selenium.
16 | // Tests for browsers other than chrome will not run.
17 | chromeOnly: true,
18 |
19 | // list of files / patterns to load in the browser
20 | specs: [
21 | 'private/src/test/**/*.spec.js'
22 | ],
23 |
24 | // Patterns to exclude.
25 | exclude: [],
26 |
27 | // ----- Capabilities to be passed to the webdriver instance ----
28 | //
29 | // For a full list of available capabilities, see
30 | // https://code.google.com/p/selenium/wiki/DesiredCapabilities
31 | // and
32 | // https://code.google.com/p/selenium/source/browse/javascript/webdriver/capabilities.js
33 | capabilities: {
34 | 'browserName': 'chrome'
35 | },
36 |
37 | // ----- The test framework -----
38 | //
39 | // Jasmine and Cucumber are fully supported as a test and assertion framework.
40 | // Mocha has limited beta support. You will need to include your own
41 | // assertion framework if working with mocha.
42 | framework: 'jasmine',
43 |
44 | // ----- Options to be passed to minijasminenode -----
45 | //
46 | // See the full list at https://github.com/juliemr/minijasminenode
47 | jasmineNodeOpts: {
48 | defaultTimeoutInterval: 30000
49 | }
50 | };
51 |
--------------------------------------------------------------------------------
/private/src/client/app/main/main.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
5 |
43 |
6 |
8 | Change Password
7 |
9 |
41 |
42 |
5 | 
12 |
13 | JS-Spark
6 | 7 |Welcome to JS-Spark project
8 |If you want to check which calculation you voluntary computed check console.
9 |Thank you for your contribution.
10 | 11 |
12 |
16 |
42 |
43 |
50 |
--------------------------------------------------------------------------------
/private/src/server/config/seedDb.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Populate DB with sample data on server start
3 | * to disable, edit config/environment/index.js, and set `seedDB: false`
4 | */
5 |
6 | 'use strict';
7 |
8 | var Thing = require('../api/thing/thing.model');
9 | var User = require('../api/user/user.model');
10 |
11 | Thing.find({}).remove(function () {
12 | Thing.create({
13 | name: 'Development Tools',
14 | info: 'Integration with popular tools such as Bower, Grunt, Karma, Mocha, JSHint, Node Inspector, Livereload, Protractor, Jade, Stylus, Sass, CoffeeScript, and Less.'
15 | }, {
16 | name: 'Server and Client integration',
17 | info: 'Built with a powerful and fun stack: MongoDB, Express, AngularJS, and Node.'
18 | }, {
19 | name: 'Smart Build System',
20 | info: 'Build system ignores `spec` files, allowing you to keep tests alongside code. Automatic injection of scripts and styles into your index.html'
21 | }, {
22 | name: 'Modular Structure',
23 | info: 'Best practice client and server structures allow for more code reusability and maximum scalability'
24 | }, {
25 | name: 'Optimized Build',
26 | info: 'Build process packs up your templates as a single JavaScript payload, minifies your scripts/css/images, and rewrites asset names for caching.'
27 | }, {
28 | name: 'Deployment Ready',
29 | info: 'Easily deploy your app to Heroku or Openshift with the heroku and openshift subgenerators'
30 | });
31 | });
32 |
33 | User.find({}).remove(function () {
34 | User.create({
35 | provider: 'local',
36 | name: 'Test User',
37 | email: 'test@test.com',
38 | password: 'test'
39 | }, {
40 | provider: 'local',
41 | role: 'admin',
42 | name: 'Admin',
43 | email: 'admin@admin.com',
44 | password: 'admin'
45 | }, function () {
46 | console.log('finished populating users');
47 | }
48 | );
49 | });
50 |
--------------------------------------------------------------------------------
/private/src/client/app/app.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var jSSparkUi = angular.module('jsSparkUiApp', [
4 | 'ngCookies',
5 | 'ngResource',
6 | 'ngSanitize',
7 | 'btford.socket-io',
8 | 'ui.router',
9 | 'ui.bootstrap',
10 | 'jQuery',
11 | '_',
12 | 'config'
13 | ])
14 | .config(function ($stateProvider, $urlRouterProvider, $locationProvider, $httpProvider) {
15 | $urlRouterProvider
16 | .otherwise('/');
17 |
18 | $locationProvider.html5Mode(true);
19 | $httpProvider.interceptors.push('authInterceptor');
20 | })
21 |
22 | .factory('authInterceptor', function ($rootScope, $q, $cookieStore, $location) {
23 | return {
24 | // Add authorization token to headers
25 | request: function (config) {
26 | config.headers = config.headers || {};
27 | if ($cookieStore.get('token')) {
28 | config.headers.Authorization = 'Bearer ' + $cookieStore.get('token');
29 | }
30 | return config;
31 | },
32 |
33 | // Intercept 401s and redirect you to login
34 | responseError: function (response) {
35 | if (response.status === 401) {
36 | $location.path('/login');
37 | // remove any stale tokens
38 | $cookieStore.remove('token');
39 | return $q.reject(response);
40 | }
41 | else {
42 | return $q.reject(response);
43 | }
44 | }
45 | };
46 | })
47 |
48 | .run(function ($rootScope, $location, Auth) {
49 | // Redirect to login if route requires auth and you're not logged in
50 | $rootScope.$on('$stateChangeStart', function (event, next) {
51 | Auth.isLoggedInAsync(function (loggedIn) {
52 | if (next.authenticate && !loggedIn) {
53 | $location.path('/login');
54 | }
55 | });
56 | });
57 | });
58 |
--------------------------------------------------------------------------------
/private/src/server/config/environment/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var path = require('path');
4 | var _ = require('lodash');
5 |
6 | function requiredProcessEnv(name) {
7 | if (!process.env[name]) {
8 | throw new Error('You must set the ' + name + ' environment variable');
9 | }
10 | return process.env[name];
11 | }
12 |
13 | // All configurations will extend these options
14 | // ============================================
15 | var all = {
16 | env: process.env.NODE_ENV,
17 |
18 | // Root path of server
19 | root: path.normalize(__dirname + '/../../..'),
20 |
21 | // Server port
22 | port: process.env.PORT || 9000,
23 |
24 | ip: 'localhost',
25 |
26 | // Should we populate the DB with sample data?
27 | seedDB: false,
28 |
29 | // Secret for session, you will want to change this and make it an environment variable
30 | secrets: {
31 | session: 'js-spark-ui-secret'
32 | },
33 |
34 | // List of user roles
35 | userRoles: ['guest', 'user', 'admin'],
36 |
37 | // MongoDB connection options
38 | mongo: {
39 | options: {
40 | db: {
41 | safe: true
42 | }
43 | }
44 | },
45 |
46 | facebook: {
47 | clientID: process.env.FACEBOOK_ID || 'id',
48 | clientSecret: process.env.FACEBOOK_SECRET || 'secret',
49 | callbackURL: process.env.DOMAIN + '/auth/facebook/callback'
50 | },
51 |
52 | twitter: {
53 | clientID: process.env.TWITTER_ID || 'id',
54 | clientSecret: process.env.TWITTER_SECRET || 'secret',
55 | callbackURL: process.env.DOMAIN + '/auth/twitter/callback'
56 | },
57 |
58 | google: {
59 | clientID: process.env.GOOGLE_ID || 'id',
60 | clientSecret: process.env.GOOGLE_SECRET || 'secret',
61 | callbackURL: process.env.DOMAIN + '/auth/google/callback'
62 | }
63 | };
64 |
65 | // Export the config object based on the NODE_ENV
66 | // ==============================================
67 | module.exports = _.merge(
68 | all,
69 | require('./' + process.env.NODE_ENV + '.js') || {});
70 |
--------------------------------------------------------------------------------
/private/src/server/config/express.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Express configuration
3 | */
4 |
5 | 'use strict';
6 |
7 | var express = require('express');
8 | var favicon = require('static-favicon');
9 | var morgan = require('morgan');
10 | var compression = require('compression');
11 | var bodyParser = require('body-parser');
12 | var methodOverride = require('method-override');
13 | var cookieParser = require('cookie-parser');
14 | var errorHandler = require('errorhandler');
15 | var path = require('path');
16 | var config = require('./environment');
17 | var passport = require('passport');
18 | var session = require('express-session');
19 | var mongoStore = require('connect-mongo')(session);
20 | var mongoose = require('mongoose');
21 |
22 | module.exports = function (app) {
23 | var env = app.get('env');
24 |
25 | app.set('views', config.root + '/server/views');
26 | app.engine('html', require('ejs').renderFile);
27 | app.set('view engine', 'html');
28 | app.use(compression());
29 | app.use(bodyParser.urlencoded({ extended: false }));
30 | app.use(bodyParser.json());
31 | app.use(methodOverride());
32 | app.use(cookieParser());
33 | app.use(passport.initialize());
34 |
35 | // Persist sessions with mongoStore
36 | // We need to enable sessions for passport twitter because its an oauth 1.0 strategy
37 | app.use(session({
38 | secret: config.secrets.session,
39 | resave: true,
40 | saveUninitialized: true,
41 | store: new mongoStore({ mongoose_connection: mongoose.connection })
42 | }));
43 |
44 | if ('production' === env) {
45 | app.use(favicon(path.join(config.root, 'public', 'favicon.ico')));
46 | app.use(express.static(path.join(config.root, 'public')));
47 | app.set('appPath', config.root + '/public');
48 | app.use(morgan('dev'));
49 | }
50 |
51 |
52 | if ('development' === env || 'test' === env) {
53 | app.use(require('connect-livereload')());
54 | app.use(express.static(path.join(config.root, '.tmp')));
55 | app.use(express.static(path.join(config.root, 'client')));
56 | app.set('appPath', 'private/src/client');
57 | app.use(morgan('dev'));
58 | app.use(errorHandler()); // Error handler - has to be last
59 | }
60 | };
61 |
--------------------------------------------------------------------------------
/private/src/server/controller/di.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Created by syzer on 4/16/2014.
3 | */
4 | module.exports = function diController(initialServices) {
5 | 'use strict';
6 |
7 | var SERVICE_INVALID = 'Invalid service';
8 | var SERVICE_DOES_NOT_EXISTS = 'Service with this name does not exist';
9 | var SERVICE_WAS_EXISTING = 'Cannot add service that exists';
10 | var services = initialServices || {};
11 |
12 | return {
13 |
14 | add: function (serviceName, service) {
15 | if (!service || !serviceName) {
16 | throw new Error(SERVICE_INVALID);
17 | }
18 | if (this.hasService(serviceName)) {
19 | throw new Error(SERVICE_WAS_EXISTING + ': ' + serviceName);
20 | }
21 | services[serviceName] = service;
22 | },
23 |
24 | /**
25 | * return service , if service is curred returns auto-curred/resolved version
26 | * @param serviceName
27 | * @returns {*}
28 | */
29 | get: function (serviceName) {
30 | if (!this.hasService(serviceName)) {
31 | throw new Error(SERVICE_DOES_NOT_EXISTS + ': ' + serviceName);
32 | }
33 | // auto-curry anonymous addService function
34 | // not sure if Function.name will be legal in next ECMA script
35 | if (('function' === typeof services[serviceName]) &&
36 | ('addService' === services[serviceName].name)) {
37 | //console.log('function ', services[serviceName].name, serviceName);
38 | services[serviceName] = services[serviceName](this);
39 | }
40 | return services[serviceName];
41 | },
42 |
43 | /** use full for testing */
44 | replace: function (serviceName, service) {
45 | if (!this.hasService(serviceName)) {
46 | throw new Error(SERVICE_DOES_NOT_EXISTS + ': ' + serviceName);
47 | }
48 | delete services[serviceName];
49 | this.add(serviceName, service);
50 | },
51 |
52 | hasService: function (serviceName) {
53 | return services.hasOwnProperty(serviceName);
54 | },
55 |
56 | //TODO merge services between modules also might merge initialServices
57 | mergeServices: function () {}
58 | };
59 | };
60 |
--------------------------------------------------------------------------------
/private/docs/readme.md:
--------------------------------------------------------------------------------
1 | internal docs like design docs
2 | + markups for auto generated user docs
3 |
4 | rules
5 | =====
6 |
7 | codding style
8 | =============
9 | tab => 4 spaces
10 |
11 | module + DI + config
12 |
13 | DI
14 | module pattern:
15 |
16 | file `strategy.js` in `clients/push/strategy`
17 | ```JavaScript
18 |
19 | module.exports = function strategyPushClients(arraySerializerService, clientQueService, when) {
20 |
21 | //private
22 | var array = [];
23 |
24 | return {
25 |
26 | // this method comment
27 | /** is also allowed */
28 | method1: function(param) {
29 | // code
30 | },
31 |
32 | // some comments
33 | push: publicFunction
34 | };
35 |
36 | // public methods
37 | function publicFunction(params) {
38 |
39 | }
40 |
41 | // private methods
42 | function privateFunction(params) {
43 |
44 | }
45 | };
46 | ```
47 |
48 | usage
49 | =====
50 |
51 | ```JavaScript
52 |
53 | var clientsPushStrategy = sm.get('model.clients.push.strategy');
54 |
55 | clientsPushStrategy.push(tasks)
56 | .then(function (clients) {
57 | //
58 | });
59 | ```
60 |
61 | instantiate
62 | -----------
63 |
64 | ```JavaScript
65 |
66 | //...
67 | 'model.strategy.push.clients': function addService(sm) {
68 | var model = require(ROOT + 'clients/push/strategy') (
69 | sm.get('service.serializer.array'),
70 | sm.get('service.que.client')
71 | sm.get('when')
72 | );
73 | return model;
74 | }
75 | ```
76 |
77 | that means we try NOT to call `new` outside object/service registry
78 | that will remove usage of singletons, also will allow easier testing
79 | and portability
80 |
81 | naming convention
82 | -----------------
83 | file `private/src/server/service/serializer/function`
84 | module name:
85 | camel case: `functionSerializerService`
86 | pascal case: `FunctionSerializerService` (if to be called with `new`)
87 |
88 | unit test file: `private/test/server/service/serializer/function`
89 | module name: `functionSerializerServiceTest`
90 |
91 |
92 | bower components are in /src/client/component
93 |
94 | why `/node_modules`?
95 | --------------------
96 | short answer: because npm is limited.
97 |
98 | promises:
99 | ---------
100 | https://github.com/cujojs/when/wiki/Examples
101 |
--------------------------------------------------------------------------------
/private/src/server/api/thing/thing.controller.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Using Rails-like standard naming convention for endpoints.
3 | * GET /things -> index
4 | * POST /things -> create
5 | * GET /things/:id -> show
6 | * PUT /things/:id -> update
7 | * DELETE /things/:id -> destroy
8 | */
9 |
10 | 'use strict';
11 |
12 | var _ = require('lodash');
13 | var Thing = require('./thing.model');
14 |
15 | // Get list of things
16 | exports.index = function (req, res) {
17 | Thing.find(function (err, things) {
18 | if (err) {
19 | return handleError(res, err);
20 | }
21 | return res.status(200).json(things);
22 | });
23 | };
24 |
25 | // Get a single thing
26 | exports.show = function (req, res) {
27 | Thing.findById(req.params.id, function (err, thing) {
28 | if (err) {
29 | return handleError(res, err);
30 | }
31 | if (!thing) {
32 | return res.status(404).end();
33 | }
34 | return res.json(thing);
35 | });
36 | };
37 |
38 | // Creates a new thing in the DB.
39 | exports.create = function (req, res) {
40 | Thing.create(req.body, function (err, thing) {
41 | if (err) {
42 | return handleError(res, err);
43 | }
44 | return res.status(201).json(thing);
45 | });
46 | };
47 |
48 | // Updates an existing thing in the DB.
49 | exports.update = function (req, res) {
50 | if (req.body._id) {
51 | delete req.body._id;
52 | }
53 | Thing.findById(req.params.id, function (err, thing) {
54 | if (err) {
55 | return handleError(res, err);
56 | }
57 | if (!thing) {
58 | return res.status(404).end();
59 | }
60 | var updated = _.merge(thing, req.body);
61 | updated.save(function (err) {
62 | if (err) {
63 | return handleError(res, err);
64 | }
65 | return res.status(200).json(thing);
66 | });
67 | });
68 | };
69 |
70 | // Deletes a thing from the DB.
71 | exports.destroy = function (req, res) {
72 | Thing.findById(req.params.id, function (err, thing) {
73 | if (err) {
74 | return handleError(res, err);
75 | }
76 | if (!thing) {
77 | return res.status(404).end();
78 | }
79 | thing.remove(function (err) {
80 | if (err) {
81 | return handleError(res, err);
82 | }
83 | return res.status(204).end();
84 | });
85 | });
86 | };
87 |
88 | function handleError(res, err) {
89 | return res.status(500).send(err);
90 | }
91 |
--------------------------------------------------------------------------------
/private/src/server/auth/auth.service.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var mongoose = require('mongoose');
4 | var passport = require('passport');
5 | var config = require('../config/environment');
6 | var jwt = require('jsonwebtoken');
7 | var expressJwt = require('express-jwt');
8 | var compose = require('composable-middleware');
9 | var User = require('../api/user/user.model');
10 | var validateJwt = expressJwt({ secret: config.secrets.session });
11 |
12 | /**
13 | * Attaches the user object to the request if authenticated
14 | * Otherwise returns 403
15 | */
16 | function isAuthenticated() {
17 | return compose()
18 | // Validate jwt
19 | .use(function (req, res, next) {
20 | // allow access_token to be passed through query parameter as well
21 | if (req.query && req.query.hasOwnProperty('access_token')) {
22 | req.headers.authorization = 'Bearer ' + req.query.access_token;
23 | }
24 | validateJwt(req, res, next);
25 | })
26 | // Attach user to request
27 | .use(function (req, res, next) {
28 | User.findById(req.user._id, function (err, user) {
29 | if (err) return next(err);
30 | if (!user) return res.status(401).end();
31 |
32 | req.user = user;
33 | next();
34 | });
35 | });
36 | }
37 |
38 | /**
39 | * Checks if the user role meets the minimum requirements of the route
40 | */
41 | function hasRole(roleRequired) {
42 | if (!roleRequired) throw new Error('Required role needs to be set');
43 |
44 | return compose()
45 | .use(isAuthenticated())
46 | .use(function meetsRequirements(req, res, next) {
47 | if (config.userRoles.indexOf(req.user.role) >= config.userRoles.indexOf(roleRequired)) {
48 | next();
49 | }
50 | else {
51 | res.send(403);
52 | }
53 | });
54 | }
55 |
56 | /**
57 | * Returns a jwt token signed by the app secret
58 | */
59 | function signToken(id) {
60 | return jwt.sign({ _id: id }, config.secrets.session, { expiresInMinutes: 60 * 5 });
61 | }
62 |
63 | /**
64 | * Set token cookie directly for oAuth strategies
65 | */
66 | function setTokenCookie(req, res) {
67 | if (!req.user) return res.status(404).json({ message: 'Something went wrong, please try again.'});
68 | var token = signToken(req.user._id, req.user.role);
69 | res.cookie('token', JSON.stringify(token));
70 | res.redirect('/');
71 | }
72 |
73 | exports.isAuthenticated = isAuthenticated;
74 | exports.hasRole = hasRole;
75 | exports.signToken = signToken;
76 | exports.setTokenCookie = setTokenCookie;
77 |
--------------------------------------------------------------------------------
/private/src/server/service/taskManager.js:
--------------------------------------------------------------------------------
1 | /**
2 | * TODO
3 | */
4 | module.exports = function taskManagerService(config, log, dispatcher, workersService, defer, promise, server, port, _) {
5 |
6 | return {
7 | init: init,
8 | addTask: addTask,
9 | getWorkers: workersService.get,
10 | stop: stop
11 | };
12 |
13 | function stop() {
14 | var stopDate = new Date();
15 | server.close();
16 | log.info('server stopped @ ' + stopDate);
17 |
18 | //dispatcher.stop(); // is closed by server
19 | return stopDate;
20 | }
21 |
22 | // TODO start server(if not started)
23 | // public methods
24 | function init() {
25 | dispatcher.start();
26 | server.listen(port);
27 | }
28 |
29 | function addTask(task, taskConfig) {
30 | taskConfig = taskConfig || '';
31 | var deferred = defer(),
32 | todos = [];
33 |
34 | dispatcher.addTask(task, deferred);
35 |
36 | if (!taskConfig.times) {
37 | return deferred.promise;
38 | }
39 |
40 | todos.push(deferred.promise);
41 |
42 | _.times(taskConfig.times - 1, function (n) {
43 | deferred = defer();
44 | dispatcher.addTask(task, deferred);
45 | todos.push(deferred.promise);
46 | });
47 |
48 | return promise
49 | .settle(todos)
50 | .then(filterFullFilled)
51 | .then(checkMajority);
52 | }
53 |
54 | function filterFullFilled(promises) {
55 | return promises
56 | .filter(function (promise) {
57 | return promise.isFulfilled(); // can be also isRejected()
58 | })
59 | .map(function (promise) {
60 | return promise.value();
61 | });
62 | }
63 |
64 | function first2MostCommon(arr) {
65 | return _(arr)
66 | .groupBy()
67 | .sortBy(function (el) {
68 | return -el.length;
69 | })
70 | .map(function firstTwo(data) {
71 | return [data[0], data[1]];
72 | })
73 | .value();
74 | }
75 |
76 | function compare2Answers(data) {
77 | if (_.isEqual(data[0], data[1])) {
78 | return data[0];
79 | } else {
80 | throw new Error('Clients calculated different things, ' +
81 | 'some may even could not finish calculations');
82 | }
83 | }
84 |
85 | // maybe would be better to send calculations to arbiter
86 | //:: array[data] -> array
87 | function checkMajority(data) {
88 | var requiredOK = parseInt(data.length / 2 + 1);
89 | if (2 === requiredOK) {
90 | return compare2Answers(data);
91 | }
92 | return first2MostCommon(data);
93 | }
94 | };
95 |
--------------------------------------------------------------------------------
/private/src/server/service/express.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Created by syzer on 4/16/2014.
3 | */
4 | module.exports = function expressService(app, port, cookieParser, compression, http/*, validator*/, session, static_) {
5 | 'use strict';
6 |
7 | var expressApp;
8 | var server;
9 | // var isValidMethod = validator.isValidMethod;
10 |
11 | return {
12 |
13 | getApp: function () {
14 | return expressApp;
15 | },
16 |
17 | getServer: function () {
18 | return server;
19 | },
20 |
21 | registerRouteHandler: function (route, handler, methodArr) {
22 | var methods = methodArr || ['GET'];
23 |
24 | if (!handler) {
25 | throw new Error('Handler invalid');
26 | }
27 | methods.forEach(function (method) {
28 | // if (!isValidMethod(method)) {
29 | // throw new Error('Method ' + method + ' disallowed!');
30 | // }
31 | console.log('Registered ', method, ' route', route,
32 | 'handler with context: ', typeof handler
33 | );
34 | if (method === 'GET') {
35 | expressApp.get(route, handler);
36 | }
37 | if (method === 'POST') {
38 | expressApp.post(route, handler);
39 | }
40 | });
41 | },
42 |
43 | setup: function () {
44 | app.use(cookieParser);
45 | app.use(compression);
46 | app.use(session);
47 | app.use('/static', static_);
48 |
49 | server = http
50 | .createServer(app)
51 | .listen(port);
52 | console.log('Listening on https://0.0.0.0:' + port);
53 |
54 | expressApp = app;
55 | },
56 |
57 | registerErrors: function () {
58 | function NotFound(msg) {
59 | this.name = 'NotFound';
60 | Error.call(this, msg);
61 | Error.captureStackTrace(this, arguments.callee);
62 | }
63 |
64 | expressApp.use(function (err, req, res, next) {
65 | console.error(err);
66 | if (err instanceof NotFound) {
67 | res.render('404.jade', { locals: {
68 | title: '404 - Not Found',
69 | description: '',
70 | author: '',
71 | analyticssiteid: 'XXXXXXX'
72 | }, status: 404 });
73 | } else {
74 | res.render('500.jade', { locals: {
75 | title: 'The Server Encountered an Error',
76 | description: '',
77 | author: '',
78 | analyticssiteid: 'XXXXXXX',
79 | error: err
80 | }, status: 500 });
81 | }
82 | });
83 | }
84 | };
85 | };
86 |
--------------------------------------------------------------------------------
/private/src/server/api/user/user.controller.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var User = require('./user.model');
4 | var passport = require('passport');
5 | var config = require('../../config/environment');
6 | var jwt = require('jsonwebtoken');
7 |
8 | var validationError = function (res, err) {
9 | return res.json(422, err);
10 | };
11 |
12 | /**
13 | * Get list of users
14 | * restriction: 'admin'
15 | */
16 | exports.index = function (req, res) {
17 | User.find({}, '-salt -hashedPassword', function (err, users) {
18 | if (err) return res.status(500).send(err);
19 | res.status(200).json(users);
20 | });
21 | };
22 |
23 | /**
24 | * Creates a new user
25 | */
26 | exports.create = function (req, res, next) {
27 | var newUser = new User(req.body);
28 | newUser.provider = 'local';
29 | newUser.role = 'user';
30 | newUser.save(function (err, user) {
31 | if (err) return validationError(res, err);
32 | var token = jwt.sign({_id: user._id }, config.secrets.session, { expiresInMinutes: 60 * 5 });
33 | res.json({ token: token });
34 | });
35 | };
36 |
37 | /**
38 | * Get a single user
39 | */
40 | exports.show = function (req, res, next) {
41 | var userId = req.params.id;
42 |
43 | User.findById(userId, function (err, user) {
44 | if (err) return next(err);
45 | if (!user) return res.send(401);
46 | res.json(user.profile);
47 | });
48 | };
49 |
50 | /**
51 | * Deletes a user
52 | * restriction: 'admin'
53 | */
54 | exports.destroy = function (req, res) {
55 | User.findByIdAndRemove(req.params.id, function (err, user) {
56 | if (err) return res.status(500).send(err);
57 | return res.status(204).end();
58 | });
59 | };
60 |
61 | /**
62 | * Change a users password
63 | */
64 | exports.changePassword = function (req, res, next) {
65 | var userId = req.user._id;
66 | var oldPass = String(req.body.oldPassword);
67 | var newPass = String(req.body.newPassword);
68 |
69 | User.findById(userId, function (err, user) {
70 | if (user.authenticate(oldPass)) {
71 | user.password = newPass;
72 | user.save(function (err) {
73 | if (err) return validationError(res, err);
74 | res.status(200).end();
75 | });
76 | } else {
77 | res.status(403).end();
78 | }
79 | });
80 | };
81 |
82 | /**
83 | * Get my info
84 | */
85 | exports.me = function (req, res, next) {
86 | var userId = req.user._id;
87 | User.findOne({
88 | _id: userId
89 | }, '-salt -hashedPassword', function (err, user) { // don't ever give out the password or salt
90 | if (err) return next(err);
91 | if (!user) return res.json(401);
92 | res.json(user);
93 | });
94 | };
95 |
96 | /**
97 | * Authentication callback
98 | */
99 | exports.authCallback = function (req, res, next) {
100 | res.redirect('/');
101 | };
102 |
--------------------------------------------------------------------------------
/private/src/client/app/account/login/login.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
17 |
28 |
29 |
41 |
18 |
27 | Features:
19 | 26 |
4 |
72 |
73 |
--------------------------------------------------------------------------------
/karma.conf.js:
--------------------------------------------------------------------------------
1 | // Karma configuration
2 | // http://karma-runner.github.io/0.10/config/configuration-file.html
3 |
4 | module.exports = function (config) {
5 | config.set({
6 | // base path, that will be used to resolve files and exclude
7 | basePath: '',
8 |
9 | // testing framework to use (jasmine/mocha/qunit/...)
10 | frameworks: ['jasmine'],
11 |
12 | // list of files / patterns to load in the browser
13 | files: [
14 | 'private/src/client/components/jquery/dist/jquery.js',
15 | 'private/src/client/components/angular/angular.js',
16 | 'private/src/client/components/angular-mocks/angular-mocks.js',
17 | 'private/src/client/components/angular-resource/angular-resource.js',
18 | 'private/src/client/components/angular-cookies/angular-cookies.js',
19 | 'private/src/client/components/angular-sanitize/angular-sanitize.js',
20 | 'private/src/client/components/angular-route/angular-route.js',
21 | 'private/src/client/components/angular-bootstrap/ui-bootstrap-tpls.js',
22 | 'private/src/client/components/lodash/dist/lodash.compat.js',
23 | 'private/src/client/components/angular-socket-io/socket.js',
24 | 'private/src/client/components/angular-ui-router/release/angular-ui-router.js',
25 | 'private/src/client/app/app.js',
26 | 'private/src/client/app/app.coffee',
27 | 'private/src/client/app/**/*.js',
28 | 'private/src/client/app/**/*.coffee',
29 | 'private/src/client/components/**/*.js',
30 | 'private/src/client/components/**/*.coffee',
31 | 'private/src/client/app/**/*.jade',
32 | 'private/src/client/components/**/*.jade',
33 | 'private/src/client/app/**/*.html',
34 | 'private/src/client/components/**/*.html'
35 | ],
36 |
37 | preprocessors: {
38 | '**/*.jade': 'ng-jade2js',
39 | '**/*.html': 'html2js',
40 | '**/*.coffee': 'coffee',
41 | },
42 |
43 | ngHtml2JsPreprocessor: {
44 | stripPrefix: 'private/src/client/'
45 | },
46 |
47 | ngJade2JsPreprocessor: {
48 | stripPrefix: 'private/src/client/'
49 | },
50 |
51 | // list of files / patterns to exclude
52 | exclude: [],
53 |
54 | // web server port
55 | port: 8080,
56 |
57 | // level of logging
58 | // possible values: LOG_DISABLE || LOG_ERROR || LOG_WARN || LOG_INFO || LOG_DEBUG
59 | logLevel: config.LOG_INFO,
60 |
61 |
62 | // enable / disable watching file and executing tests whenever any file changes
63 | autoWatch: false,
64 |
65 |
66 | // Start these browsers, currently available:
67 | // - Chrome
68 | // - ChromeCanary
69 | // - Firefox
70 | // - Opera
71 | // - Safari (only Mac)
72 | // - PhantomJS
73 | // - IE (only Windows)
74 | browsers: ['PhantomJS'],
75 |
76 |
77 | // Continuous Integration mode
78 | // if true, it capture browsers, run tests and exit
79 | singleRun: false
80 | });
81 | };
82 |
--------------------------------------------------------------------------------
/private/src/server/service/jsSpark.js:
--------------------------------------------------------------------------------
1 | module.exports = function jsSParkService(taskManager, _) {
2 |
3 | // is a monad
4 | // TODO use newChainedMethod not to double code and change run()
5 | return function jsSpark(data) {
6 |
7 | var operations = [],
8 | array = data;
9 |
10 | return {
11 |
12 | // TODO move dynamic method dispatch to apply/call
13 | // array generics are still not available in node
14 | // add lodash function
15 | add: function (/*args*/) {
16 | operations.push({
17 | chaining: function (chain, functions, _) {
18 | return chain[functions[0]](functions[1]);
19 | },
20 | callback: Array.prototype.slice.call(arguments)
21 | });
22 |
23 | return this;
24 | },
25 |
26 | map: function (callback) {
27 | operations.push({
28 | chaining: function (chain, callback) {
29 | return chain.map(callback);
30 | },
31 | callback: callback
32 | });
33 |
34 | return this;
35 | },
36 |
37 | filter: function (callback) {
38 | operations.push({
39 | chaining: function (chain, callback) {
40 | return chain.filter(callback);
41 | },
42 | callback: callback
43 | });
44 |
45 | return this;
46 | },
47 |
48 | reduce: function (callback) {
49 | operations.push({
50 | chaining: function (chain, callback) {
51 | return chain.reduce(callback);
52 | },
53 | callback: callback
54 | });
55 |
56 | return this;
57 | },
58 |
59 | thru: function (callback) {
60 | operations.push({
61 | chaining: function (chain, callback) {
62 | return chain.thru(callback);
63 | },
64 | callback: callback
65 | });
66 |
67 | return this;
68 | },
69 |
70 | run: run,
71 |
72 | stop: taskManager.stop
73 | };
74 |
75 | // TODO move forEach to reduce?
76 | // TODO args = options{timeout,...}
77 | // factory method
78 | // :: object -> deferred
79 | function run(taskConfig) {
80 | var task = {
81 |
82 | operations: operations,
83 |
84 | execute: function (_, data) {
85 | var chain = _.chain(data);
86 | this.operations.forEach(function (operation, i) {
87 | chain = operation.chaining(chain, operation.callback.bind(_), _);
88 | });
89 |
90 | return chain;
91 | },
92 |
93 | data: array
94 | };
95 |
96 | return taskManager.addTask(task, taskConfig);
97 | }
98 | }
99 | };
100 |
--------------------------------------------------------------------------------
/private/src/client/app/account/signup/signup.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
5 |
71 |
6 |
15 | Login
7 | 8 |Accounts are reset on server restart from
9 | server/config/seed.js. Default account is
10 | test@test.com / test
11 |
Admin account is admin@admin.com / admin
16 |
17 |
69 |
70 | 72 |
4 |
82 |
83 |
--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Created by syzer on 7/24/2014.
3 | */
4 | 'use strict';
5 |
6 | var jsSpark,
7 | taskManager,
8 | _;
9 |
10 | var ROOT = './private/src/server/';
11 | // DI container
12 | var services = require(ROOT + 'config/di').services;
13 |
14 | // setup Dependencies
15 | var di = require(ROOT + 'controller/di')(services);
16 |
17 | // start listening on given port
18 | //di.get('server').listen(di.get('port'));
19 |
20 | jsSpark = di.get('service.jsSpark');
21 |
22 | // lodash
23 | _ = di.get('_');
24 |
25 | taskManager = di.get('service.taskManager');
26 |
27 | module.exports = function (config) {
28 | config = config || {};
29 |
30 | if (config.workers) {
31 | di.get('service.fork').forkWorker({times: config.workers});
32 | }
33 |
34 | return {
35 | di: di,
36 | jsSpark: jsSpark,
37 | taskManager: taskManager,
38 | q: di.get('promise')
39 | }
40 | };
41 |
42 | // TODO move to examples
43 | /**
44 | module.exports({workers: 2});
45 |
46 | var task, task2, task3, doElections;
47 |
48 | task = jsSpark(_.range(10))
49 | // https://lodash.com/docs#sortBy
50 | .thru(function (arr) {
51 | return this.sortBy(arr, function _sortBy(el) {
52 | return Math.sin(el);
53 | })
54 | })
55 | .map(function multiplyBy2(el) {
56 | return el * 2;
57 | })
58 | .filter(function remove5and10(el) {
59 | return el % 5 !== 0;
60 | })
61 | // sum of [ 2, 4, 6, 8, 12, 14, 16, 18 ] => 80
62 | .reduce(function sumUp(arr, el) {
63 | return arr + el;
64 | })
65 | .run();
66 |
67 | // client side heavy CPU computation
68 | task2 = jsSpark([20])
69 | .map(function addOne(num) {
70 | return num + 1;
71 | })
72 | .run();
73 |
74 | task3 = task
75 | .then(function serverSideComputingOfData(data) {
76 | var basesNumber = data + 21;
77 | // All your 101 base are belong to us
78 | console.log('All your ' + basesNumber + ' base are belong to us');
79 | return basesNumber;
80 | })
81 | .catch(function (reason) {
82 | console.log('Task could not compute ' + reason.toString());
83 | });
84 |
85 | di.get('promise')
86 | .all([task, task2, task3])
87 | .then(function (data) {
88 | console.log('Tasks 1 to 3 done', data);
89 | });
90 |
91 | doElections = jsSpark(_.range(10))
92 | .reduce(function sumUp(sum, num) {
93 | return sum + num;
94 | })
95 | // how many times repeat calculations
96 | .run({times: 3})
97 | .then(function whenClientsFinished(data) {
98 | // may also get 2 most relevant answers
99 | console.log('Most clients believe that:');
100 | console.log('Total sum of numbers from 1 to 10 is:', data);
101 | })
102 | .catch(function whenClientsArgue(reason) {
103 | console.log('Most clients could not agree, ', +reason.toString());
104 | });
105 |
106 | setTimeout(
107 | function delayedTask() {
108 | jsSpark(_.range(1000))
109 | .filter(function isOdd(num) {
110 | return num % 2;
111 | })
112 | .reduce(function sumUp(sum, num) {
113 | return sum + num;
114 | })
115 | .thru(function plusOne(sum) {
116 | return sum + 1;
117 | })
118 | .run()
119 | .then(function (data) {
120 | console.log('Total sum of 1 to 1000 odd numbers +1 is:', data);
121 | })
122 | .catch(function (reason) {
123 | console.log('Task could not compute ' + reason.toString());
124 | });
125 | }, 5000
126 | );
127 | */
128 |
--------------------------------------------------------------------------------
/private/src/server/service/workers.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Created by syzer on 7/24/2014.
3 | * workersSocket - utilized for observing changes in workers
4 | */
5 | module.exports = function workersService(log, _) {
6 | 'use strict';
7 |
8 | var workers = [];
9 | var listeners = [];
10 |
11 | return {
12 | create: create,
13 | getFreeWorkers: getFreeWorkers,
14 | remove: remove,
15 | get: get,
16 | getFirstFree: getFirstFree,
17 | busy: busy,
18 | free: free,
19 | addListener: addListener
20 | };
21 |
22 | //TODO notify change
23 | function create(socket) {
24 | var worker = {
25 | socket: socket,
26 | free: true,
27 | points: 0,
28 | _id: socket.id
29 | };
30 | workers.push(worker);
31 | notifyThat('client:save', worker);
32 |
33 | return worker;
34 | }
35 |
36 | function remove(worker) {
37 | var index = workers.indexOf(worker);
38 | if (index != -1) {
39 | log.info('RIP client', workers[index].socket.id);
40 | workers.splice(index, 1);
41 | }
42 | notifyThat('client:remove', worker);
43 | }
44 |
45 | // { socket:
46 | // { nsp: [Object],
47 | // server: [Object],
48 | // adapter: [Object],
49 | // id: 'haQJ-zLwkTFof2RVAAAB',
50 | // client: [Object],
51 | // conn: [Object],
52 | // rooms: [Object],
53 | // acks: {},
54 | // connected: true,
55 | // disconnected: false,
56 | // handshake: [Object],
57 | // address: 'undefined:undefined',
58 | // connectedAt: Mon Oct 27 2014 21:37:46 GMT+0100 (W. Europe Standard Time),
59 | // _events: [Object]
60 | // },
61 | // free: false,
62 | // points: 4,
63 | // id: 'haQJ-zLwkTFof2RVAAAB' },
64 | function get() {
65 | return _(workers)
66 | .map(extractImportantWorkerInfo)
67 | .value();
68 | }
69 |
70 | function extractImportantWorkerInfo(worker) {
71 | return {
72 | _id: worker._id,
73 | connectedAt: worker.socket.connectedAt,
74 | connected: worker.socket.connected,
75 | handshake: worker.socket.handshake,
76 | free: worker.free,
77 | rooms: worker.socket.rooms,
78 | points: worker.points,
79 | benchmark: worker.benchmark
80 | }
81 | }
82 |
83 | // + getFirstFree::array -> object
84 | function getFirstFree() {
85 | return _.findWhere(workers, { free: true });
86 | }
87 |
88 | //TODO getBest
89 | function getFreeWorkers() {
90 | return workers.filter(function (worker) {
91 | return worker.free;
92 | });
93 | }
94 |
95 | // maybe make a worker class
96 | // free worker from busy state
97 | function free(worker, points) {
98 | points = points || 0;
99 | worker.free = true;
100 | worker.points += points;
101 | notifyThat('client:save', worker);
102 | }
103 |
104 | function busy(worker) {
105 | worker.free = false;
106 | notifyThat('client:save', worker);
107 | }
108 |
109 | //TODO maybe room broadcast
110 | function notifyThat(action, actor) {
111 | actor = extractImportantWorkerInfo(actor);
112 | listeners.forEach(function(listener){
113 | listener.emit(action, actor);
114 | });
115 | }
116 |
117 | function addListener(socket) {
118 | listeners.push(socket);
119 | }
120 |
121 | };
122 |
--------------------------------------------------------------------------------
/private/src/server/api/user/user.model.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var mongoose = require('mongoose');
4 | var Schema = mongoose.Schema;
5 | var crypto = require('crypto');
6 | var authTypes = ['github', 'twitter', 'facebook', 'google'];
7 |
8 | var UserSchema = new Schema({
9 | name: String,
10 | email: { type: String, lowercase: true },
11 | role: {
12 | type: String,
13 | default: 'user'
14 | },
15 | hashedPassword: String,
16 | provider: String,
17 | salt: String,
18 | facebook: {},
19 | twitter: {},
20 | google: {},
21 | github: {}
22 | });
23 |
24 | /**
25 | * Virtuals
26 | */
27 | UserSchema
28 | .virtual('password')
29 | .set(function (password) {
30 | this._password = password;
31 | this.salt = this.makeSalt();
32 | this.hashedPassword = this.encryptPassword(password);
33 | })
34 | .get(function () {
35 | return this._password;
36 | });
37 |
38 | // Public profile information
39 | UserSchema
40 | .virtual('profile')
41 | .get(function () {
42 | return {
43 | 'name': this.name,
44 | 'role': this.role
45 | };
46 | });
47 |
48 | // Non-sensitive info we'll be putting in the token
49 | UserSchema
50 | .virtual('token')
51 | .get(function () {
52 | return {
53 | '_id': this._id,
54 | 'role': this.role
55 | };
56 | });
57 |
58 | /**
59 | * Validations
60 | */
61 |
62 | // Validate empty email
63 | UserSchema
64 | .path('email')
65 | .validate(function (email) {
66 | if (authTypes.indexOf(this.provider) !== -1) return true;
67 | return email.length;
68 | }, 'Email cannot be blank');
69 |
70 | // Validate empty password
71 | UserSchema
72 | .path('hashedPassword')
73 | .validate(function (hashedPassword) {
74 | if (authTypes.indexOf(this.provider) !== -1) return true;
75 | return hashedPassword.length;
76 | }, 'Password cannot be blank');
77 |
78 | // Validate email is not taken
79 | UserSchema
80 | .path('email')
81 | .validate(function (value, respond) {
82 | var self = this;
83 | this.constructor.findOne({email: value}, function (err, user) {
84 | if (err) throw err;
85 | if (user) {
86 | if (self.id === user.id) return respond(true);
87 | return respond(false);
88 | }
89 | respond(true);
90 | });
91 | }, 'The specified email address is already in use.');
92 |
93 | var validatePresenceOf = function (value) {
94 | return value && value.length;
95 | };
96 |
97 | /**
98 | * Pre-save hook
99 | */
100 | UserSchema
101 | .pre('save', function (next) {
102 | if (!this.isNew) return next();
103 |
104 | if (!validatePresenceOf(this.hashedPassword) && authTypes.indexOf(this.provider) === -1)
105 | next(new Error('Invalid password'));
106 | else
107 | next();
108 | });
109 |
110 | /**
111 | * Methods
112 | */
113 | UserSchema.methods = {
114 | /**
115 | * Authenticate - check if the passwords are the same
116 | *
117 | * @param {String} plainText
118 | * @return {Boolean}
119 | * @api public
120 | */
121 | authenticate: function (plainText) {
122 | return this.encryptPassword(plainText) === this.hashedPassword;
123 | },
124 |
125 | /**
126 | * Make salt
127 | *
128 | * @return {String}
129 | * @api public
130 | */
131 | makeSalt: function () {
132 | return crypto.randomBytes(16).toString('base64');
133 | },
134 |
135 | /**
136 | * Encrypt password
137 | *
138 | * @param {String} password
139 | * @return {String}
140 | * @api public
141 | */
142 | encryptPassword: function (password) {
143 | if (!password || !this.salt) return '';
144 | var salt = new Buffer(this.salt, 'base64');
145 | return crypto.pbkdf2Sync(password, salt, 10000, 64).toString('base64');
146 | }
147 | };
148 |
149 | module.exports = mongoose.model('User', UserSchema);
150 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "js-spark",
3 | "description": "Distributed calculation / data processing system. Run computation/jobs on 1000+ cores",
4 | "author": "syzer
5 |
81 |
6 |
8 | Sign up
7 |
9 |
79 |
80 | 82 |
144 |
158 |
159 |
160 |
--------------------------------------------------------------------------------
/private/src/client/index.html:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
8 |
9 |
10 |
11 |
12 |
13 | Not found :(
145 | 146 |Sorry, but the page you were trying to view does not exist.
147 | 148 |It looks like this was the result of either:
149 |-
150 |
- a mistyped address 151 |
- an out-of-date link 152 |