Test2

categories/categories.client.module.js

@@ -0,0 +1,4 @@
+'use strict';
+
+// Use application configuration module to register a new module
+ApplicationConfiguration.registerModule('core');

categories/category-server-model.server.model.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+var mongoose = require('mongoose'),
+  Schema = mongoose.Schema;
+
+function validateLength (v) {
+    // a custom validation function for checking string length to be used by the model
+    return v.length <= 15;
+}
+/**
+ * CategoryServerModel Schema
+ */
+var CategoryServerModelSchema = new Schema({
+    created:{
+        type:Date,
+        default:Date.now
+    },
+    description:{
+        type:String,
+        default:'',
+        trin:true
+    },
+    name: {
+        type: String,
+        default: '',
+        trim: true,
+        unique : true,
+        // make this a required field
+        required: 'name cannot be blank',
+        // wires in a custom validator function (http://mongoosejs.com/docs/api.html#schematype_SchemaType-validate).
+        validate: [validateLength, 'name must be 15 chars in length or less']
+    }
+  // CategoryServerModel model fields
+  // ...
+});
+
+mongoose.model('CategoryServerModel', CategoryServerModelSchema);

categories/config.js

@@ -0,0 +1,186 @@
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+var _ = require('lodash'),
+  chalk = require('chalk'),
+  glob = require('glob'),
+  fs = require('fs'),
+  path = require('path');
+
+/**
+ * Get files by glob patterns
+ */
+var getGlobbedPaths = function (globPatterns, excludes) {
+  // URL paths regex
+  var urlRegex = new RegExp('^(?:[a-z]+:)?\/\/', 'i');
+
+  // The output array
+  var output = [];
+
+  // If glob pattern is array so we use each pattern in a recursive way, otherwise we use glob
+  if (_.isArray(globPatterns)) {
+    globPatterns.forEach(function (globPattern) {
+      output = _.union(output, getGlobbedPaths(globPattern, excludes));
+    });
+  } else if (_.isString(globPatterns)) {
+    if (urlRegex.test(globPatterns)) {
+      output.push(globPatterns);
+    } else {
+      var files = glob.sync(globPatterns);
+      if (excludes) {
+        files = files.map(function (file) {
+          if (_.isArray(excludes)) {
+            for (var i in excludes) {
+              file = file.replace(excludes[i], '');
+            }
+          } else {
+            file = file.replace(excludes, '');
+          }
+          return file;
+        });
+      }
+      output = _.union(output, files);
+    }
+  }
+
+  return output;
+};
+
+/**
+ * Validate NODE_ENV existance
+ */
+var validateEnvironmentVariable = function () {
+  var environmentFiles = glob.sync('./config/env/' + process.env.NODE_ENV + '.js');
+  console.log();
+  if (!environmentFiles.length) {
+    if (process.env.NODE_ENV) {
+      console.error(chalk.red('+ Error: No configuration file found for "' + process.env.NODE_ENV + '" environment using development instead'));
+    } else {
+      console.error(chalk.red('+ Error: NODE_ENV is not defined! Using default development environment'));
+    }
+    process.env.NODE_ENV = 'development';
+  }
+  // Reset console color
+  console.log(chalk.white(''));
+};
+
+/**
+ * Validate Secure=true parameter can actually be turned on
+ * because it requires certs and key files to be available
+ */
+var validateSecureMode = function (config) {
+
+  if (config.secure !== true) {
+    return true;
+  }
+
+  var privateKey = fs.existsSync('./config/sslcerts/key.pem');
+  var certificate = fs.existsSync('./config/sslcerts/cert.pem');
+
+  if (!privateKey || !certificate) {
+    console.log(chalk.red('+ Error: Certificate file or key file is missing, falling back to non-SSL mode'));
+    console.log(chalk.red('  To create them, simply run the following from your shell: sh ./scripts/generate-ssl-certs.sh'));
+    console.log();
+    config.secure = false;
+  }
+};
+
+/**
+ * Initialize global configuration files
+ */
+var initGlobalConfigFolders = function (config, assets) {
+  // Appending files
+  config.folders = {
+    server: {},
+    client: {}
+  };
+
+  // Setting globbed client paths
+  config.folders.client = getGlobbedPaths(path.join(process.cwd(), 'modules/*/client/'), process.cwd().replace(new RegExp(/\\/g), '/'));
+};
+
+/**
+ * Initialize global configuration files
+ */
+var initGlobalConfigFiles = function (config, assets) {
+  // Appending files
+  config.files = {
+    server: {},
+    client: {}
+  };
+
+  // Setting Globbed model files
+  config.files.server.models = getGlobbedPaths(assets.server.models);
+
+  // Setting Globbed route files
+  config.files.server.routes = getGlobbedPaths(assets.server.routes);
+
+  // Setting Globbed config files
+  config.files.server.configs = getGlobbedPaths(assets.server.config);
+
+  // Setting Globbed socket files
+  config.files.server.sockets = getGlobbedPaths(assets.server.sockets);
+
+  // Setting Globbed policies files
+  config.files.server.policies = getGlobbedPaths(assets.server.policies);
+
+  // Setting Globbed js files
+  config.files.client.js = getGlobbedPaths(assets.client.lib.js, 'public/').concat(getGlobbedPaths(assets.client.js, ['client/', 'public/']));
+
+  // Setting Globbed css files
+  config.files.client.css = getGlobbedPaths(assets.client.lib.css, 'public/').concat(getGlobbedPaths(assets.client.css, ['client/', 'public/']));
+
+  // Setting Globbed test files
+  config.files.client.tests = getGlobbedPaths(assets.client.tests);
+};
+
+/**
+ * Initialize global configuration
+ */
+var initGlobalConfig = function () {
+  // Validate NDOE_ENV existance
+  validateEnvironmentVariable();
+
+  // Get the default assets
+  var defaultAssets = require(path.join(process.cwd(), 'config/assets/default'));
+
+  // Get the current assets
+  var environmentAssets = require(path.join(process.cwd(), 'config/assets/', process.env.NODE_ENV)) || {};
+
+  // Merge assets
+  var assets = _.merge(defaultAssets, environmentAssets);
+
+  // Get the default config
+  var defaultConfig = require(path.join(process.cwd(), 'config/env/default'));
+
+  // Get the current config
+  var environmentConfig = require(path.join(process.cwd(), 'config/env/', process.env.NODE_ENV)) || {};
+
+  // Merge config files
+  var envConf = _.merge(defaultConfig, environmentConfig);
+
+  var config = _.merge(envConf, (fs.existsSync(path.join(process.cwd(), 'config/env/local.js')) && require(path.join(process.cwd(), 'config/env/local.js'))) || {});
+
+  // Initialize global globbed files
+  initGlobalConfigFiles(config, assets);
+
+  // Initialize global globbed folders
+  initGlobalConfigFolders(config, assets);
+
+  // Validate Secure SSL mode can be used
+  validateSecureMode(config);
+
+  // Expose configuration utilities
+  config.utils = {
+    getGlobbedPaths: getGlobbedPaths
+  };
+
+  return config;
+};
+
+/**
+ * Set configuration object
+ */
+module.exports = initGlobalConfig();

categories/core.server.controller.js

@@ -0,0 +1,113 @@
+'use strict';
+exports.renderIndex = function (req, res) {
+    res.render('modules/core/server/views/index', {
+        user: req.user || null
+    });
+};
+
+/**
+ * Render the server error page
+ */
+exports.renderServerError = function (req, res) {
+    res.status(500).render('modules/core/server/views/500', {
+        error: 'Oops! Something went wrong...'
+    });
+};
+
+/**
+ * Render the server not found responses
+ * Performs content-negotiation on the Accept HTTP header
+ */
+exports.renderNotFound = function (req, res) {
+
+    res.status(404).format({
+        'text/html': function () {
+            res.render('modules/core/server/views/404', {
+                url: req.originalUrl
+            });
+        },
+        'application/json': function () {
+            res.json({
+                error: 'Path not found'
+            });
+        },
+        'default': function () {
+            res.send('Path not found');
+        }
+    });
+};
+
+/**
+ * Module dependencies.
+ */
+var path = require('path'),
+    mongoose = require('mongoose'),
+    Category = mongoose.model('CategoryServerModel'),
+    errorHandler = require(path.resolve('./modules/core/server/controllers/errors.server.controller')),
+    _ = require('lodash');
+
+/**
+ * Create a Core
+ */
+exports.create = function (req, res) {
+    var category=new Category(req.body);
+    category.save(function(err) {
+        if (err) {
+            return res.status(400).send({
+                message: errorHandler.getErrorMessage(err)
+            });
+        } else {
+            res.status(201).json(category);
+        }
+    });
+};
+
+/**
+ * Show the current Core
+ */
+exports.read = function (req, res) {
+    Category.findById(req.params.categoryId).exec(function(err, category) {
+        if (err) {
+            return res.status(400).send({
+                message: errorHandler.getErrorMessage(err)
+            });
+        } else {
+            if (!category) {
+                return res.status(404).send({
+                    message: 'Category not found'
+                });
+            }
+            res.json(category);
+        }
+    });
+};
+
+/**
+ * Update a Core
+ */
+exports.update = function (req, res) {
+
+};
+
+/**
+ * Delete an Core
+ */
+exports.delete = function (req, res) {
+
+};
+
+/**
+ * List of Cores
+ */
+exports.list = function (req, res) {
+    Category.find().exec(function(err,categories){
+        if(err){
+            return res.status(400).send({
+                message:errorHandler.getErrorMessage(err)
+            });
+        }else{
+            res.json(categories);
+        }
+    });
+
+};

categories/routes.server.routes.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = function(app) {
+    var categories=require('../../server/controllers/core.server.controller');
+    app.route('/categories')
+        .get(categories.list)
+        .post(categories.create);
+
+
+    app.route('/categories/:categoryId')
+        .get(categories.read);
+  // Routing logic   
+  // ...
+};

categories/server.js

@@ -0,0 +1,7 @@
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+var app = require('./config/lib/app');
+var server = app.start();