Merge branch 'develop' of http://gitlab.ujaen.es/yotta/pictogram into develop

sails/INSTALL.md

@@ -21,7 +21,7 @@ mostradas más adelante hacen todo el trabajo, basta con ejecutar [./install.sh]
  3. Descargar Pictogram del repositorio e iniciar instalación
 
     ```
-    $ git clone http://scm.ujaen.es/softuno/pictogram.git
+    $ git clone http://gitlab.ujaen.es/yotta/pictogram.git
     $ cd pictogram/sails
     $ sudo ./install.sh
     ```

sails/install.sh

 #!/bin/bash
 
+#
+# - Encoding and locale for virtual machine
+# - Build-essentials and g++
+# - Ansible install
+# - Run ansible playbook
+#
+
 # keymap and system encoding
 echo "-- Configuring encoding and locale"
 sudo localectl set-keymap es
+export LANGUAGE=en_US.UTF-8
 export LANG=en_US.UTF-8
+export LC_ALL=en_US.UTF-8
+locale-gen en_US.UTF-8
+dpkg-reconfigure locales
 
 echo "-- Installing build-essentials and g++"
-sudo apt-get update
+sudo apt-get update -y
 sudo apt-get install -y build-essential g++
 
 # installing ansible
@@ -42,3 +53,6 @@ else
   echo "XX Playbook not found, provision not finished"
   exit
 fi
+
+# overwrite sails-mysql
+yes | sudo cp -rf /vagrant/src/node_modules_overwrite/sails-mysql/* /vagrant/src/node_modules/sails-mysql/

sails/pictoload.sh

 #!/bin/bash
 
+#
+# Install core pictos (symbolstx and upload)
+#
+
 cd /vagrant/
 
 echo "--Descargando coleccion de pictogramas"

sails/src/assets/app/bower.json

@@ -2,7 +2,7 @@
   "name": "angular-pictogram",
   "description": "Client side dashboard in AngularJS",
   "version": "0.0.0",
-  "homepage": "http://scm.ujaen.es/softuno/pictogram.git",
+  "homepage": "http://gitlab.ujaen.es/yotta/pictogram.git",
   "license": "Private",
   "private": true,
   "dependencies": {

sails/src/assets/scripts/modules/login/controllers/login.js

@@ -85,13 +85,11 @@ function LoginCtrl(
       $scope.submitted = false;
       delete $window.sessionStorage.token;
       if (err.search("without students") > 0) {
-        $translate('no_students_for_user').then(function (translation) {
-          ngToast.warning({ content: translation });
-        });
+          ngToast.warning($translate.instant('no_students_for_user'));
       } else if (err.search("not been activated") > 0) {
-        $translate('inactive_account').then(function (translation) {
-          ngToast.danger({ content: translation });
-        });
+          ngToast.danger($translate.instant('inactive_account'));
+      } else {
+	  ngToast.danger($translate.instant("login_fail"));
       }
     });
   };

sails/src/assets/scripts/modules/login/views/login.html

 <!-- Office image -->
-<div class="row">
+<div class="header-image">
+  <div class="row">
     <div class="col-md-12 text-center">
-    <!-- Logo Pictogram
-    <p>
-      <img src="img/logo_pictogram.png" alt="Pictogram" title="Pictogram" />
-    </p>
-    -->
-    <p>&nbsp;</p>
-    <p class="text-center">
       <img ng-src="{{office.logoUrl}}" alt="{{office.name}}" title="{{office.name}}">
-    </p>
+    </div>
   </div>
 </div>
 <!--/. Office image -->
 
-<!-- Main row -->
-<div class="row">
+<br>
+
+<div id="main-content" class="container">
+  <div class="row">
 
     <!-- Form column and offset -->
     <div class="col-md-4 col-md-offset-2">
@@ -33,14 +29,8 @@
             <label translate>password</label>:
             <input type="password" class="form-control" id="login_password" placeholder="{{ 'your_password' | translate}}" required ng-model="credentials.password" />
           </div>
-        <!-- Remember -->
-        <div class="checkbox">
-          <label>
-            <input type="checkbox" id="login_savepassword" ng-model="credentials.savepassword" />{{ 'remember' | translate }}
-          </label>
-        </div>
           <div class="row">
-          <div class="col-md-12">
+            <div class="col-xs-6">
               <!-- Login -->
               <div class="pull-left">
                 <button type="submit" class="btn btn-primary" translate>login</button>
@@ -49,17 +39,27 @@
               <div class="pull-left">
                 <i ng-class="{'fa fa-spinner fa-spin fa-2x fa-fw margin-bottom': true, 'spin_disabled': !submitted}"></i>
               </div>
-            <!-- Create account -->
-            <div class="pull-right margin-top7">
-              <a href="/app/#/signin" translate>create_an_account</a>
+            </div>
+            <div class="col-xs-6 margin-top7">
+              <!-- Remember -->
+              <div class="checkbox">
+                <label>
+                  <input type="checkbox" id="login_savepassword" ng-model="credentials.savepassword" />{{ 'remember' | translate }}
+                </label>
               </div>
             </div>
           </div>
-        <!-- Remember password -->
-        <div class="text-center margin-top15">
+
           <br>
+
+          <!-- Remember password -->
+          <div class="row text-center">
             <a href="/app/#/changepass" translate>password_forgotten</a>
           </div>
+          <!-- Create account -->
+          <div class="row text-center">
+            <a href="/app/#/signin" translate>create_an_account</a>
+          </div>
         </form>
       </div>
       <!--/. login -->
@@ -67,12 +67,12 @@
     <!--/. form column -->
 
     <!-- Image column -->
-  <div class="col-md-4">
+    <div class="col-xs-12 col-md-4 text-center">
        <img src="img/login.png" alt="Pictogram" title="Pictogram" />
     </div>
     <!--/. image column -->
 
+  </div>
 </div>
-<!--/. main row -->
 
 <footer-translate></footer-translate>

sails/src/assets/scripts/modules/student/controllers/collections.js

@@ -325,7 +325,6 @@ dashboardControllers.controller('StudentCollectionsCtrl', function StudentCollec
       if(!pictoId)
         return;
 
-      // Send the picto to the server
       $http.put(config.backend + '/stu/' + $scope.studentData.id + '/cat', {
         prev_id_stu_pic: picto_cat.id,
         new_id_pic: pictoId

sails/src/node_modules_overwrite/README.md

+Files contained here are intented to overwrite dependencies code, because of a enhacement or a bug not included in official distributions and done by us.

sails/src/node_modules_overwrite/sails-mysql/lib/sql.js

+/**
+ * Module Dependencies
+ */
+
+var mysql = require('mysql');
+var _ = require('lodash');
+var utils = require('./utils');
+
+var sql = module.exports = {
+
+  // Convert mysql format to standard javascript object
+  normalizeSchema: function (schema) {
+    return _.reduce(schema, function(memo, field) {
+
+      // Marshal mysql DESCRIBE to waterline collection semantics
+      var attrName = field.Field;
+      var type = field.Type;
+
+      // Remove (n) column-size indicators
+      type = type.replace(/\([0-9]+\)$/,'');
+
+      memo[attrName] = {
+        type: type,
+        defaultsTo: field.Default,
+        autoIncrement: field.Extra === 'auto_increment'
+      };
+
+      if(field.primaryKey) {
+        memo[attrName].primaryKey = field.primaryKey;
+      }
+
+      if(field.unique) {
+        memo[attrName].unique = field.unique;
+      }
+
+      if(field.indexed) {
+        memo[attrName].indexed = field.indexed;
+      }
+
+      return memo;
+    }, {});
+  },
+
+  // @returns ALTER query for adding a column
+  addColumn: function (collectionName, attrName, attrDef) {
+    // Escape table name and attribute name
+    var tableName = mysql.escapeId(collectionName);
+
+    // sails.log.verbose("ADDING ",attrName, "with",attrDef);
+
+    // Build column definition
+    var columnDefinition = sql._schema(collectionName, attrDef, attrName);
+
+    return 'ALTER TABLE ' + tableName + ' ADD ' + columnDefinition;
+  },
+
+  // @returns ALTER query for dropping a column
+  removeColumn: function (collectionName, attrName) {
+    // Escape table name and attribute name
+    var tableName = mysql.escapeId(collectionName);
+    attrName = mysql.escapeId(attrName);
+
+    return 'ALTER TABLE ' + tableName + ' DROP COLUMN ' + attrName;
+  },
+
+  countQuery: function(collectionName, options, tableDefs){
+    var query = 'SELECT count(*) as count from `' + collectionName + '`';
+    return query += sql.serializeOptions(collectionName, options, tableDefs);
+  },
+
+  // Create a schema csv for a DDL query
+  schema: function(collectionName, attributes) {
+    return sql.build(collectionName, attributes, sql._schema);
+  },
+
+  _schema: function(collectionName, attribute, attrName) {
+    attrName = mysql.escapeId(attrName);
+    var type = sqlTypeCast(attribute);
+
+    // Process PK field
+    if(attribute.primaryKey) {
+
+      var columnDefinition = attrName + ' ' + type;
+
+      // If type is an integer, set auto increment
+      if(type === 'TINYINT' || type === 'SMALLINT' || type === 'INT' || type === 'BIGINT') {
+        return columnDefinition + ' UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY';
+      }
+
+      // Just set NOT NULL on other types
+      return columnDefinition + ' NOT NULL PRIMARY KEY';
+    }
+
+    // Process NOT NULL field.
+    // if notNull is true, set NOT NULL constraint
+    var nullPart = '';
+    if (attribute.notNull) {
+      nullPart = ' NOT NULL ';
+    }
+
+    // Process UNIQUE field
+    if(attribute.unique) {
+      return attrName + ' ' + type + nullPart + ' UNIQUE KEY';
+    }
+
+    // Process INDEX field (NON-UNIQUE KEY)
+    if(attribute.index) {
+      return attrName + ' ' + type + nullPart + ', INDEX(' + attrName + ')';
+    }
+
+    return attrName + ' ' + type + ' ' + nullPart;
+  },
+
+  // Create an attribute csv for a DQL query
+  attributes: function(collectionName, attributes) {
+    return sql.build(collectionName, attributes, sql.prepareAttribute);
+  },
+
+  // Create a value csv for a DQL query
+  // key => optional, overrides the keys in the dictionary
+  values: function(collectionName, values, key) {
+    return sql.build(collectionName, values, sql.prepareValue, ', ', key);
+  },
+
+  prepareCriterion: function(collectionName, value, key, parentKey) {
+    // Special sub-attr case
+    if (validSubAttrCriteria(value)) {
+      return sql.where(collectionName, value, null, key);
+
+    }
+
+    // Build escaped attr and value strings using either the key,
+    // or if one exists, the parent key
+    var attrStr, valueStr;
+
+
+    // Special comparator case
+    if (parentKey) {
+
+      attrStr = sql.prepareAttribute(collectionName, value, parentKey);
+      valueStr = sql.prepareValue(collectionName, value, parentKey);
+
+      // Why don't we strip you out of those bothersome apostrophes?
+      var nakedButClean = String(valueStr).replace(new RegExp('^\'+|\'+$', 'g'), '');
+
+      if (key === '<' || key === 'lessThan') {
+        return attrStr + '<' + valueStr;
+      }
+      else if (key === '<=' || key === 'lessThanOrEqual') {
+        return attrStr + '<=' + valueStr;
+      }
+      else if (key === '>' || key === 'greaterThan') {
+        return attrStr + '>' + valueStr;
+      }
+      else if (key === '>=' || key === 'greaterThanOrEqual') {
+        return attrStr + '>=' + valueStr;
+      }
+      else if (key === '!' || key === 'not') {
+        if (value === null) {
+          return attrStr + ' IS NOT NULL';
+        }
+        else if (_.isArray(value)) {
+          return attrStr + ' NOT IN(' + valueStr + ')';
+        }
+        else {
+          return attrStr + '<>' + valueStr;
+        }
+      }
+      else if (key === 'like') {
+        return attrStr + ' LIKE \'' + nakedButClean + '\'';
+      }
+      else if (key === 'contains') {
+        return attrStr + ' LIKE \'%' + nakedButClean + '%\'';
+      }
+      else if (key === 'startsWith') {
+        return attrStr + ' LIKE \'' + nakedButClean + '%\'';
+      }
+      else if (key === 'endsWith') {
+        return attrStr + ' LIKE \'%' + nakedButClean + '\'';
+      }
+      else {
+        throw new Error('Unknown comparator: ' + key);
+      }
+    } else {
+      attrStr = sql.prepareAttribute(collectionName, value, key);
+      valueStr = sql.prepareValue(collectionName, value, key);
+
+      // Special IS NULL case
+      if (_.isNull(value)) {
+        return attrStr + ' IS NULL';
+      } else {
+        return attrStr + '=' + valueStr;
+      }
+    }
+  },
+
+  prepareValue: function(collectionName, value, attrName) {
+
+    // Cast dates to SQL
+    if (_.isDate(value)) {
+      value = toSqlDate(value);
+    }
+
+    // Cast functions to strings
+    if (_.isFunction(value)) {
+      value = value.toString();
+    }
+
+    // Escape (also wraps in quotes)
+    return mysql.escape(value);
+  },
+
+  prepareAttribute: function(collectionName, value, attrName) {
+    return mysql.escapeId(collectionName) + '.' + mysql.escapeId(attrName);
+  },
+
+  // // Starting point for predicate evaluation
+  // // parentKey => if set, look for comparators and apply them to the parent key
+  where: function(collectionName, where, key, parentKey) {
+    return sql.build(collectionName, where, sql.predicate, ' AND ', undefined, parentKey);
+  },
+
+  // Recursively parse a predicate calculus and build a SQL query
+  predicate: function(collectionName, criterion, key, parentKey) {
+    var queryPart = '';
+
+
+    if (parentKey) {
+      return sql.prepareCriterion(collectionName, criterion, key, parentKey);
+    }
+
+    // OR
+    if (key.toLowerCase() === 'or') {
+      queryPart = sql.build(collectionName, criterion, sql.where, ' OR ');
+      return ' ( ' + queryPart + ' ) ';
+    }
+
+    // AND
+    else if (key.toLowerCase() === 'and') {
+      queryPart = sql.build(collectionName, criterion, sql.where, ' AND ');
+      return ' ( ' + queryPart + ' ) ';
+    }
+
+    // IN
+    else if (_.isArray(criterion)) {
+      queryPart = sql.prepareAttribute(collectionName, null, key) + ' IN (' + sql.values(collectionName, criterion, key) + ')';
+      return queryPart;
+    }
+
+    // LIKE
+    else if (key.toLowerCase() === 'like') {
+      return sql.build(collectionName, criterion, function(collectionName, value, attrName) {
+        var attrStr = sql.prepareAttribute(collectionName, value, attrName);
+
+
+        // TODO: Handle regexp criterias
+        if (_.isRegExp(value)) {
+          throw new Error('RegExp LIKE criterias not supported by the MySQLAdapter yet.  Please contribute @ http://github.com/balderdashy/sails-mysql');
+        }
+
+        var valueStr = sql.prepareValue(collectionName, value, attrName);
+
+        // Handle escaped percent (%) signs [encoded as %%%]
+        valueStr = valueStr.replace(/%%%/g, '\\%');
+
+        return attrStr + ' LIKE ' + valueStr;
+      }, ' AND ');
+    }
+
+    // NOT
+    else if (key.toLowerCase() === 'not') {
+      throw new Error('NOT not supported yet!');
+    }
+
+    // Basic criteria item
+    else {
+      return sql.prepareCriterion(collectionName, criterion, key);
+    }
+
+  },
+
+  serializeOptions: function(collectionName, options, tableDefs) {
+
+    // Join clause
+    // allow the key to be named with join or joins
+    var joins = options.join || options.joins || [];
+
+    if (joins.length > 0) {
+      return this.buildJoinQuery(collectionName, joins, options, tableDefs);
+    }
+
+    return this.buildSingleQuery(collectionName, options, tableDefs);
+  },
+
+  /**
+   * Build Up a Select Statement Without Joins
+   */
+
+  buildSingleQuery: function(collectionName, options, tableDefs) {
+    var queryPart = '';
+
+    if(options.where) {
+      queryPart += 'WHERE ' + sql.where(collectionName, options.where) + ' ';
+    }
+
+    if (options.groupBy) {
+      queryPart += 'GROUP BY ';
+
+      // Normalize to array
+      if(!_.isArray(options.groupBy)) {
+        options.groupBy = [options.groupBy];
+      }
+
+      _.each(options.groupBy, function(key) {
+        queryPart += key + ', ';
+      });
+
+      // Remove trailing comma
+      queryPart = queryPart.slice(0, -2) + ' ';
+    }
+
+    if (options.sort) {
+      queryPart += 'ORDER BY ';
+
+      // Sort through each sort attribute criteria
+      _.each(options.sort, function(direction, attrName) {
+
+        queryPart += sql.prepareAttribute(collectionName, null, attrName) + ' ';
+
+        // Basic MongoDB-style numeric sort direction
+        if (direction === 1) {
+          queryPart += 'ASC, ';
+        } else {
+          queryPart += 'DESC, ';
+        }
+      });
+
+      // Remove trailing comma
+      if(queryPart.slice(-2) === ', ') {
+        queryPart = queryPart.slice(0, -2) + ' ';
+      }
+    }
+
+    if (_.has(options, 'limit') && (options.limit !== null && options.limit !== undefined)) {
+      queryPart += 'LIMIT ' + options.limit + ' ';
+    }
+
+    if (_.has(options, 'skip') && (options.skip !== null && options.skip !== undefined)) {
+      // Some MySQL hackery here.  For details, see:
+      // http://stackoverflow.com/questions/255517/mysql-offset-infinite-rows
+      if (!options.limit) {
+          queryPart += 'LIMIT 18446744073709551610 ';
+      }
+      queryPart += 'OFFSET ' + options.skip + ' ';
+    }
+
+    return queryPart;
+  },
+
+  // Put together the CSV aggregation
+  // separator => optional, defaults to ', '
+  // keyOverride => optional, overrides the keys in the dictionary
+  //          (used for generating value lists in IN queries)
+  // parentKey => key of the parent to this object
+  build: function(collectionName, collection, fn, separator, keyOverride, parentKey) {
+    separator = separator || ', ';
+    var $sql = '';
+    _.each(collection, function(value, key) {
+      $sql += fn(collectionName, value, keyOverride || key, parentKey);
+
+      // (always append separator)
+      $sql += separator;
+    });
+
+    // (then remove final one)
+    return String($sql).replace(new RegExp(separator + '+$'), '');
+  }
+};
+
+// Cast waterline types into SQL data types
+function sqlTypeCast(attr) {
+  var type;
+  var size;
+  var expandedType;
+
+  if(_.isObject(attr) && _.has(attr, 'type')) {
+    type = attr.type;
+  } else {
+    type = attr;
+  }
+
+  type = type && type.toLowerCase();
+
+  switch (type) {
+    case 'string': {
+      size = 255; // By default.
+
+      // If attr.size is positive integer, use it as size of varchar.
+      if(!Number.isNaN(attr.size) && (parseInt(attr.size) === parseFloat(attr.size)) && (parseInt(attr.size) > 0)) {
+        size = attr.size;
+      }
+
+      expandedType = 'VARCHAR(' + size + ')';
+      break;
+    }
+
+    case 'text':
+    case 'array':
+    case 'json':
+      expandedType = 'LONGTEXT';
+      break;
+
+    case 'mediumtext':
+      expandedType = 'mediumtext';
+      break;
+
+    case 'longtext':
+      expandedType = 'longtext';
+      break;
+
+    case 'boolean':
+      expandedType = 'BOOL';
+      break;
+
+    case 'int':
+    case 'integer': {
+      size = 32; // By default
+
+      if(!Number.isNaN(attr.size) && (parseInt(attr.size) === parseFloat(attr.size)) && (parseInt(size) > 0)) {
+        size = parseInt(attr.size);
+      }
+
+      // MEDIUMINT gets internally promoted to INT so there is no real benefit
+      // using it.
+
+      switch (size) {
+        case 8:
+          expandedType = 'TINYINT';
+          break;
+        case 16:
+          expandedType = 'SMALLINT';
+          break;
+        case 32:
+          expandedType = 'INT';
+          break;
+        case 64:
+          expandedType = 'BIGINT';
+          break;
+        default:
+          expandedType = 'INT';
+          break;
+      }
+
+      break;
+    }
+
+    case 'float':
+    case 'double':
+      expandedType = 'FLOAT';
+      break;
+
+    case 'decimal':
+      expandedType = 'DECIMAL';
+      break;
+
+    case 'date':
+      expandedType = 'DATE';
+      break;
+
+    case 'datetime':
+      expandedType = 'DATETIME(3)';
+      break;
+
+    case 'time':
+      expandedType = 'TIME';
+      break;
+
+    case 'binary':
+      expandedType = 'BLOB';
+      break;
+
+    default:
+      console.error('Unregistered type given: ' + type);
+      expandedType = 'LONGTEXT';
+      break;
+  }
+
+  return expandedType;
+}
+
+function wrapInQuotes(val) {
+  return '"' + val + '"';
+}
+
+function toSqlDate(date) {
+
+  date = date.getFullYear() + '-' +
+    ('00' + (date.getMonth()+1)).slice(-2) + '-' +
+    ('00' + date.getDate()).slice(-2) + ' ' +
+    ('00' + date.getHours()).slice(-2) + ':' +
+    ('00' + date.getMinutes()).slice(-2) + ':' +
+    ('00' + date.getSeconds()).slice(-2) + "." +
+    ('00' + date.getMilliseconds()).slice(-3);
+
+  return date;
+}
+
+// Return whether this criteria is valid as an object inside of an attribute
+function validSubAttrCriteria(c) {
+  return _.isObject(c) && (
+  !_.isUndefined(c.not) || !_.isUndefined(c.greaterThan) || !_.isUndefined(c.lessThan) ||
+  !_.isUndefined(c.greaterThanOrEqual) || !_.isUndefined(c.lessThanOrEqual) || !_.isUndefined(c['<']) ||
+  !_.isUndefined(c['<=']) || !_.isUndefined(c['!']) || !_.isUndefined(c['>']) || !_.isUndefined(c['>=']) ||
+  !_.isUndefined(c.startsWith) || !_.isUndefined(c.endsWith) || !_.isUndefined(c.contains) || !_.isUndefined(c.like));
+}

sails/src/node_modules_overwrite/sails-mysql/lib/utils.js

+/**
+ * Utility Functions
+ */
+
+// Dependencies
+var mysql = require('mysql');
+var _ = require('lodash');
+var url = require('url');
+
+// Module Exports
+
+var utils = module.exports = {};
+
+/**
+ * Parse URL string from config
+ *
+ * Parse URL string into connection config parameters
+ */
+
+utils.parseUrl = function (config) {
+  if(!_.isString(config.url)) {
+    return config;
+  }
+
+  var obj = url.parse(config.url);
+
+  config.host = obj.hostname || config.host;
+  config.port = obj.port || config.port;
+
+  if(_.isString(obj.pathname)) {
+    config.database = obj.pathname.split('/')[1] || config.database;
+  }
+
+  if(_.isString(obj.auth)) {
+    config.user = obj.auth.split(':')[0] || config.user;
+    config.password = obj.auth.split(':')[1] || config.password;
+  }
+  return config;
+};
+
+/**
+ * Prepare values
+ *
+ * Transform a JS date to SQL date and functions
+ * to strings.
+ */
+
+utils.prepareValue = function(value) {
+
+  if(_.isUndefined(value) || value === null) {
+    return value;
+  }
+
+  // Cast functions to strings
+  if (_.isFunction(value)) {
+    value = value.toString();
+  }
+
+  // Store Arrays and Objects as strings
+  if (_.isArray(value) || value.constructor && value.constructor.name === 'Object') {
+    try {
+      value = JSON.stringify(value);
+    } catch (e) {
+      // just keep the value and let the db handle an error
+      value = value;
+    }
+  }
+
+  // Cast dates to SQL
+  if (_.isDate(value)) {
+    value = utils.toSqlDate(value);
+  }
+
+  return mysql.escape(value);
+};
+
+/**
+ * Builds a Select statement determining if Aggeregate options are needed.
+ */
+
+utils.buildSelectStatement = function(criteria, table, schemaDefs) {
+
+  var query = '';
+
+  if(criteria.groupBy || criteria.sum || criteria.average || criteria.min || criteria.max) {
+    query = 'SELECT ';
+
+    // Append groupBy columns to select statement
+    if(criteria.groupBy) {
+      if(_.isArray(criteria.groupBy)) {
+        _.each(criteria.groupBy, function(opt){
+          query += opt + ', ';
+        });
+
+      } else {
+        query += criteria.groupBy + ', ';
+      }
+    }
+
+    // Handle SUM
+    if (criteria.sum) {
+      if(_.isArray(criteria.sum)) {
+        _.each(criteria.sum, function(opt){
+          query += 'SUM(' + opt + ') AS ' + opt + ', ';
+        });
+
+      } else {
+        query += 'SUM(' + criteria.sum + ') AS ' + criteria.sum + ', ';
+      }
+    }
+
+    // Handle AVG (casting to float to fix percision with trailing zeros)
+    if (criteria.average) {
+      if(_.isArray(criteria.average)) {
+        _.each(criteria.average, function(opt){
+          query += 'AVG(' + opt + ') AS ' + opt + ', ';
+        });
+
+      } else {
+        query += 'AVG(' + criteria.average + ') AS ' + criteria.average + ', ';
+      }
+    }
+
+    // Handle MAX
+    if (criteria.max) {
+      if(_.isArray(criteria.max)) {
+        _.each(criteria.max, function(opt){
+          query += 'MAX(' + opt + ') AS ' + opt + ', ';
+        });
+
+      } else {
+        query += 'MAX(' + criteria.max + ') AS ' + criteria.max + ', ';
+      }
+    }
+
+    // Handle MIN
+    if (criteria.min) {
+      if(_.isArray(criteria.min)) {
+        _.each(criteria.min, function(opt){
+          query += 'MIN(' + opt + ') AS ' + opt + ', ';
+        });
+
+      } else {
+        query += 'MIN(' + criteria.min + ') AS ' + criteria.min + ', ';
+      }
+    }
+
+    // trim trailing comma
+    query = query.slice(0, -2) + ' ';
+
+    // Add FROM clause
+    return query += 'FROM `' + table + '` ';
+  }
+
+  /**
+   * If no aggregate options lets just build a normal query
+   */
+
+
+  // Add all keys to the select statement for this table
+  query += 'SELECT ';
+
+  var selectKeys = [],
+      joinSelectKeys = [];
+
+  if ( !schemaDefs[table] ) {
+    throw new Error('Schema definition missing for table: `'+table+'`');
+  }
+
+  _.each(schemaDefs[table], function(schemaDef, key) {
+    selectKeys.push({ table: table, key: key });
+  });
+
+  // Check for joins
+  if(criteria.joins || criteria.join) {
+
+    var joins = criteria.joins || criteria.join;
+
+    _.each(joins, function(join) {
+      if(!join.select) {
+        return;
+      }
+
+      _.each(_.keys(schemaDefs[join.child.toLowerCase()]), function(key) {
+        var _join = _.cloneDeep(join);
+        _join.key = key;
+        joinSelectKeys.push(_join);
+      });
+
+      // Remove the foreign key for this join from the selectKeys array
+      selectKeys = selectKeys.filter(function(select) {
+        var keep = true;
+        if(select.key === join.parentKey && join.removeParentKey) {
+          keep = false;
+        }
+        return keep;
+      });
+    });
+  }
+
+  // Add all the columns to be selected that are not joins
+  _.each(selectKeys, function(select) {
+    query += '`' + select.table + '`.`' + select.key + '`, ';
+  });
+
+  // Add all the columns from the joined tables
+  _.each(joinSelectKeys, function(select) {
+
+    // Create an alias by prepending the child table with the alias of the join
+    var alias = select.alias.toLowerCase() + '_' + select.child.toLowerCase();
+
+    // If this is a belongs_to relationship, keep the foreign key name from the AS part
+    // of the query. This will result in a selected column like: "user"."id" AS "user_id__id"
+    if(select.model) {
+      return query += mysql.escapeId(alias) + '.' + mysql.escapeId(select.key) + ' AS ' +
+                      mysql.escapeId(select.parentKey + '__' + select.key) + ', ';
+    }
+
+    // If a junctionTable is used, the child value should be used in the AS part of the
+    // select query.
+    if(select.junctionTable) {
+      return query += mysql.escapeId(alias) + '.' + mysql.escapeId(select.key) + ' AS ' +
+                      mysql.escapeId(select.alias + '__' + select.key) + ', ';
+    }
+
+    // Else if a hasMany attribute is being selected, use the alias plus the child
+    return query += mysql.escapeId(alias) + '.' + mysql.escapeId(select.key) + ' AS ' +
+                    mysql.escapeId(select.alias + '__' + select.key) + ', ';
+  });
+
+  // Remove the last comma
+  query = query.slice(0, -2) + ' FROM `' + table + '` ';
+
+  return query;
+};
+
+
+utils.toSqlDate = function toSqlDate(date) {
+
+  date = date.getFullYear() + '-' +
+    ('00' + (date.getMonth()+1)).slice(-2) + '-' +
+    ('00' + date.getDate()).slice(-2) + ' ' +
+    ('00' + date.getHours()).slice(-2) + ':' +
+    ('00' + date.getMinutes()).slice(-2) + ':' +
+    ('00' + date.getSeconds()).slice(-2) + "." +
+    ('00' + date.getMilliseconds()).slice(-3);
+
+  return date;
+};

sails/src/package.json

@@ -41,7 +41,7 @@
   "main": "app.js",
   "repository": {
     "type": "git",
-    "url": "http://scm.ujaen.es/softuno/pictogram.git"
+    "url": "http://gitlab.ujaen.es/yotta/pictogram.git"
   },
   "author": "Yottacode",
   "license": "",